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.csv1'))
Memory usage of dataframe is 62099672.00 MB
Memory usage after optimization is: 16520303.00 MB
Decreased by 73.4%
continuous_feature_names = [x for x in sample_feature.columns if x not in ['price','brand','model','brand']]
一、线性回归 & 五折交叉验证 & 模拟真实业务情况
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']
1、建立模型
from sklearn.linear_model import LinearRegression
model = LinearRegression(normalize=True)
model = model.fit(train_X, train_y)
查看训练的线性回归模型的截距（intercept）与权重(coef)
'intercept:'+ str(model.intercept_)
sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True)
[('v_6', 3367064.3416419057),
('v_8', 700675.560939892),
('v_9', 170630.27723222843),
('v_7', 32322.661932037005),
('v_12', 20473.67079699449),
('v_3', 17868.079541513765),
('v_11', 11474.938996727224),
('v_13', 11261.76456002154),
('v_10', 2683.920090598985),
('gearbox', 881.8225039249779),
('fuelType', 363.90425072177175),
('bodyType', 189.60271012068114),
('city', 44.94975120523235),
('power', 28.553901616753844),
('brand_price_median', 0.5103728134078268),
('brand_price_std', 0.4503634709262942),
('brand_amount', 0.14881120395066458),
('brand_price_max', 0.0031910186703154276),
('SaleID', 5.3559899198604194e-05),
('offerType', 1.085083931684494e-05),
('seller', -1.564621925354004e-07),
('train', -9.801937267184258e-06),
('brand_price_sum', -2.1750068681877473e-05),
('name', -0.00029800127130055304),
('used_time', -0.0025158943328828093),
('brand_price_average', -0.40490484510106556),
('brand_price_min', -2.2467753486891),
('power_bin', -34.42064411728076),
('v_14', -274.7841180780339),
('kilometer', -372.8975266607397),
('notRepairedDamage', -495.1903844629193),
('v_0', -2045.0549573549326),
('v_5', -11022.986240482483),
('v_4', -15121.731109861388),
('v_2', -26098.29992056384),
('v_1', -45556.18929727631)]
from matplotlib import pyplot as plt
subsample_index=np.random.randint(low=0,high=len(train_y),size=50)
绘制特征v_9的值与标签的散点图，图片发现模型的预测结果（蓝色点）与真实标签（黑色点）的分布差异较大，且部分预测值出现了小于0的情况，说明我们的模型存在一些问题
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
通过作图我们发现数据的标签（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
<matplotlib.axes._subplots.AxesSubplot at 0x2a45afe7c08>
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
<matplotlib.axes._subplots.AxesSubplot at 0x2a45ae90248>
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.750749465558325
[('v_9', 8.052409900567737),
('v_5', 5.764236596654317),
('v_12', 1.6182081236824382),
('v_1', 1.47983105829801),
('v_11', 1.166901656362573),
('v_13', 0.9404711296038619),
('v_7', 0.7137273083566267),
('v_3', 0.6837875771100311),
('v_0', 0.008500518010162666),
('power_bin', 0.008497969302895347),
('gearbox', 0.00792237727832671),
('fuelType', 0.006684769706822457),
('bodyType', 0.004523520092703118),
('power', 0.0007161894205355506),
('brand_price_min', 3.3343511147503836e-05),
('brand_amount', 2.89787970427731e-06),
('brand_price_median', 1.257117287306966e-06),
('brand_price_std', 6.65917636347407e-07),
('brand_price_max', 6.194956307514886e-07),
('brand_price_average', 5.9993459649912e-07),
('SaleID', 2.119417003964968e-08),
('offerType', 1.4716761143063195e-10),
('train', 1.0956568985420745e-11),
('seller', -6.517097972391639e-11),
('brand_price_sum', -1.5126504215917065e-10),
('name', -7.015512588914707e-08),
('used_time', -4.122479372350757e-06),
('city', -0.002218782481042247),
('v_14', -0.004234223418139287),
('kilometer', -0.013835866226883271),
('notRepairedDamage', -0.2702794234984611),
('v_4', -0.8315701200997698),
('v_2', -0.9470842241656949),
('v_10', -1.6261466689762132),
('v_8', -40.34300748761575),
('v_6', -238.7903638550687)]
再次进行可视化，发现预测结果与真实值较为接近，且未出现异常状况
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
2、五折交叉验证
五折交叉验证
在使用训练集对参数进行训练的时候，经常会发现人们通常会将一整个训练集分为三个部分（比如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.5s finished
使用线性回归模型，对未处理标签的特征数据进行五折交叉验证
print('AVG:', np.mean(scores))
AVG: 1.3658023920314224
使用线性回归模型，对处理过标签的特征数据进行五折交叉验证
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 | 1.348304 | 1.36349 | 1.380712 | 1.378401 | 1.358105 |
3、模拟真实业务情况
但在事实上，由于我们并不具有预知未来的能力，五折交叉验证在某些与时间相关的数据集上反而反映了不真实的情况。通过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.19577667270300966
4、绘制学习率曲线与验证曲线
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)
<module 'matplotlib.pyplot' from 'C:\\Users\\ASUS\\anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py'>
5、多种模型对比
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)
线性模型 & 嵌入式特征选择
在过滤式和包裹式特征选择方法中，特征选择过程与学习器训练过程有明显的分别。而嵌入式特征选择在学习器训练过程中自动地进行特征选择。嵌入式选择最常用的是L1正则化与L2正则化。在对线性回归模型加入两种正则化方法后，他们分别变成了岭回归与Lasso回归。
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
1、对三种方法的效果对比
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.74787709086648
<matplotlib.axes._subplots.AxesSubplot at 0x2a462c0cf88>
L2正则化在拟合过程中通常都倾向于让权值尽可能小，最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单，能适应不同的数据集，也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程，若参数很大，那么只要数据偏移一点点，就会对结果造成很大的影响；但如果参数足够小，数据偏移得多一点也不会对结果造成什么影响，专业一点的说法是『抗扰动能力强』
model = Ridge().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
intercept:4.6717097880636445
<matplotlib.axes._subplots.AxesSubplot at 0x2a45ffdfac8>
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.672182402894254
<matplotlib.axes._subplots.AxesSubplot at 0x2a45ffa2948>
除此之外，决策树通过信息熵或GINI指数选择分裂节点时，优先选择的分裂特征也更加重要，这同样是一种特征选择的方法。XGBoost与LightGBM模型中的model_importance指标正是基于此计算的
2、非线性模型
除了线性模型以外，还有许多我们常用的非线性模型如下，在此篇幅有限不再一一讲解原理。我们选择了部分常用模型与线性模型进行效果比对。
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.199670 | 0.132744 | 0.168900 | 1306.671096 | 0.142333 | 0.141546 |
| cv2 | 0.193758 | 0.193024 | 0.134444 | 0.171831 | 2380.982395 | 0.140987 | 0.145501 |
| cv3 | 0.194132 | 0.189354 | 0.133798 | 0.170900 | 385.745693 | 0.139266 | 0.143887 |
| cv4 | 0.191825 | 0.189948 | 0.132695 | 0.169083 | 595.589784 | 0.137399 | 0.142497 |
| cv5 | 0.195758 | 0.203979 | 0.137303 | 0.174088 | 146.011062 | 0.143998 | 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 = []
3、贪心调参
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())])
<matplotlib.axes._subplots.AxesSubplot at 0x2a44eaf9d08>
4、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.13754820909576437
5、贝叶斯调参
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.8344 [0m | [0m 33.73 [0m | [0m 95.41 [0m | [0m 8.641 [0m | [0m 0.1147 [0m |
| [95m 2 [0m | [95m 0.8656 [0m | [95m 75.55 [0m | [95m 41.5 [0m | [95m 63.51 [0m | [95m 0.6542 [0m |
| [0m 3 [0m | [0m 0.8631 [0m | [0m 89.16 [0m | [0m 17.89 [0m | [0m 49.12 [0m | [0m 0.6141 [0m |
| [0m 4 [0m | [0m 0.8586 [0m | [0m 22.61 [0m | [0m 92.23 [0m | [0m 33.13 [0m | [0m 0.694 [0m |
| [0m 5 [0m | [0m 0.8654 [0m | [0m 93.25 [0m | [0m 19.3 [0m | [0m 61.58 [0m | [0m 0.1474 [0m |
| [0m 6 [0m | [0m 0.8063 [0m | [0m 2.514 [0m | [0m 5.291 [0m | [0m 97.72 [0m | [0m 0.5839 [0m |
| [95m 7 [0m | [95m 0.8688 [0m | [95m 98.25 [0m | [95m 98.56 [0m | [95m 93.67 [0m | [95m 0.2299 [0m |
| [0m 8 [0m | [0m 0.8634 [0m | [0m 7.179 [0m | [0m 97.83 [0m | [0m 98.77 [0m | [0m 0.8264 [0m |
| [0m 9 [0m | [0m 0.802 [0m | [0m 4.236 [0m | [0m 2.713 [0m | [0m 3.004 [0m | [0m 0.414 [0m |
| [0m 10 [0m | [0m 0.8661 [0m | [0m 73.88 [0m | [0m 38.95 [0m | [0m 65.44 [0m | [0m 0.6369 [0m |
| [0m 11 [0m | [0m 0.8673 [0m | [0m 52.29 [0m | [0m 99.41 [0m | [0m 76.15 [0m | [0m 0.2901 [0m |
| [0m 12 [0m | [0m 0.8635 [0m | [0m 99.9 [0m | [0m 79.41 [0m | [0m 51.64 [0m | [0m 0.9082 [0m |
| [95m 13 [0m | [95m 0.8692 [0m | [95m 99.62 [0m | [95m 53.77 [0m | [95m 98.54 [0m | [95m 0.8751 [0m |
| [0m 14 [0m | [0m 0.8062 [0m | [0m 2.773 [0m | [0m 98.79 [0m | [0m 65.14 [0m | [0m 0.2008 [0m |
| [0m 15 [0m | [0m 0.7719 [0m | [0m 98.34 [0m | [0m 6.885 [0m | [0m 2.329 [0m | [0m 0.525 [0m |
| [0m 16 [0m | [0m 0.8692 [0m | [0m 99.2 [0m | [0m 2.556 [0m | [0m 97.85 [0m | [0m 0.6196 [0m |
| [95m 17 [0m | [95m 0.8694 [0m | [95m 23.18 [0m | [95m 67.7 [0m | [95m 99.77 [0m | [95m 0.9661 [0m |
| [0m 18 [0m | [0m 0.8548 [0m | [0m 35.39 [0m | [0m 48.03 [0m | [0m 25.16 [0m | [0m 0.7678 [0m |
| [0m 19 [0m | [0m 0.8692 [0m | [0m 52.45 [0m | [0m 2.143 [0m | [0m 98.26 [0m | [0m 0.7692 [0m |
| [0m 20 [0m | [0m 0.869 [0m | [0m 52.32 [0m | [0m 99.57 [0m | [0m 99.49 [0m | [0m 0.7015 [0m |
| [0m 21 [0m | [0m 0.8638 [0m | [0m 44.6 [0m | [0m 2.122 [0m | [0m 51.66 [0m | [0m 0.8916 [0m |
| [0m 22 [0m | [0m 0.8578 [0m | [0m 62.59 [0m | [0m 99.21 [0m | [0m 31.64 [0m | [0m 0.9133 [0m |
| [0m 23 [0m | [0m 0.8644 [0m | [0m 50.7 [0m | [0m 75.4 [0m | [0m 53.16 [0m | [0m 0.8651 [0m |
| [95m 24 [0m | [95m 0.8694 [0m | [95m 68.0 [0m | [95m 24.91 [0m | [95m 99.98 [0m | [95m 0.8188 [0m |
| [0m 25 [0m | [0m 0.867 [0m | [0m 76.81 [0m | [0m 2.829 [0m | [0m 73.14 [0m | [0m 0.9601 [0m |
| [0m 26 [0m | [0m 0.8667 [0m | [0m 98.5 [0m | [0m 99.67 [0m | [0m 72.17 [0m | [0m 0.7852 [0m |
| [0m 27 [0m | [0m 0.8694 [0m | [0m 27.92 [0m | [0m 90.61 [0m | [0m 99.9 [0m | [0m 0.5294 [0m |
| [0m 28 [0m | [0m 0.8692 [0m | [0m 38.72 [0m | [0m 31.19 [0m | [0m 97.74 [0m | [0m 0.918 [0m |
| [0m 29 [0m | [0m 0.8693 [0m | [0m 62.72 [0m | [0m 67.48 [0m | [0m 99.47 [0m | [0m 0.7722 [0m |
| [0m 30 [0m | [0m 0.8679 [0m | [0m 88.91 [0m | [0m 82.25 [0m | [0m 81.06 [0m | [0m 0.9711 [0m |
=========================================================================
1 - rf_bo.max['target']
0.13059340636289962
在本章中，我们完成了建模与调参的工作，并对我们的模型进行了验证。此外，我们还采用了一些基本方法来提高预测的精度，提升如下图所示.
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])
<matplotlib.axes._subplots.AxesSubplot at 0x2a401836608>
以上学习网址：https://tianchi.aliyun.com/notebook-ai/detail?spm=5176.12586969.1002.6.1cd8593aMBRHoH&postId=95460
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
