天池龙珠数据挖掘训练营 Task4 学习笔记（建模调参）

cndrip

已于 2022-04-08 21:31:11 修改

阅读量1.3k

点赞数

分类专栏：机器学习文章标签：数据挖掘

于 2022-04-06 13:11:16 首次发布

本文链接：https://blog.csdn.net/cndrip/article/details/123976946

版权

机器学习专栏收录该内容

38 篇文章 20 订阅

订阅专栏

天池龙珠数据挖掘训练营学习笔记

前言

有了前面的数据处理后，本节开始建模调参。
通过本节的学习，基本了解常用的机器学习模型，并掌握机器学习模型的建模与调参流程。

一、学习知识点概要

线性回归模型
模型性能验证
嵌入式特征选择
模型对比
模型调参

二、学习内容

0 各种模型的原理

1 读取处理好的数据

import pandas as pd
import numpy as np
import warnings
warnings.filterwarnings('ignore')

优化
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%

continuous_feature_names = [x for x in sample_feature.columns if x not in ['price','brand','model','brand']]

2 线性回归 & 五折交叉验证 & 模拟真实业务情况

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']

2.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)
'''
以下是部分结果
intercept:-110670.68277225681
[('v_6', 3367064.3416418377),
 ('v_8', 700675.5609399044),
 ('v_9', 170630.2772322616),
'''

分别对v_6、v_8 和 v_9 进行可视化

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()

绘制特征v_9的值与标签的散点图，图片发现模型的预测结果（蓝色点）与真实标签（黑色点）的分布差异较大，且部分预测值出现了小于0的情况，说明我们的模型存在一些问题。

通过作图我们发现数据的标签（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)])

未处理
在这里我们对标签进行了 $l o g (x + 1)$ 变换，使标签贴近于正态分布

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)])

处理后重新建模

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.75074572712829
[('v_9', 8.052411938253034),
, ('v_5', 5.76424821734175),
, ('v_12', 1.6182065931157121),
, ('v_1', 1.479830409604984),
'''

再次进行可视化，发现预测结果与真实值较为接近，且未出现异常状况

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()

2.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)]: Done 5 out of 5 | elapsed: 6.5s finished
使用线性回归模型，对未处理标签的特征数据进行五折交叉验证

print('AVG:', np.mean(scores))
# AVG: 1.3658024040276566

使用线性回归模型，对处理过标签的特征数据进行五折交叉验证

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)]: Done 5 out of 5 | elapsed: 8.4s finished

print('AVG:', np.mean(scores))
# AVG: 0.1932530155796405

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

2.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.19577667149549252

2.4 绘制学习率曲线与验证曲线

from sklearn.model_selection import learning_curve, validation_curve
# ? learning_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)

3 多种模型对比

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)

3.1 线性模型 & 嵌入式特征选择

本章节默认，学习者已经了解关于过拟合、模型复杂度、正则化等概念。否则请寻找相关资料或参考如下连接：

 - 用简单易懂的语言描述「过拟合 overfitting」？ https://www.zhihu.com/question/32246256/answer/55320482
 - 模型复杂度与模型的泛化能力 http://yangyingming.com/article/434/
 - 正则化的直观理解 https://blog.csdn.net/jinping_shi/article/details/52433975

在过滤式和包裹式特征选择方法中，特征选择过程与学习器训练过程有明显的分别。而嵌入式特征选择在学习器训练过程中自动地进行特征选择。嵌入式选择最常用的是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')

运行后，对三种方法的效果对比

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_))
# intercept:18.750751045631276
sns.barplot(abs(model.coef_), continuous_feature_names)

line
L2正则化在拟合过程中通常都倾向于让权值尽可能小，最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单，能适应不同的数据集，也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程，若参数很大，那么只要数据偏移一点点，就会对结果造成很大的影响；但如果参数足够小，数据偏移得多一点也不会对结果造成什么影响，专业一点的说法是『抗扰动能力强』

model = Ridge().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
# intercept:4.671710811023084
sns.barplot(abs(model.coef_), continuous_feature_names)

ridge
L1正则化有助于生成一个稀疏权值矩阵，进而可以用于特征选择。如下图，我们发现power与userd_time特征非常重要。

model = Lasso().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
# intercept:8.67218477236799
sns.barplot(abs(model.coef_), continuous_feature_names)

lasso
除此之外，决策树通过信息熵或GINI指数选择分裂节点时，优先选择的分裂特征也更加重要，这同样是一种特征选择的方法。XGBoost与LightGBM模型中的model_importance指标正是基于此计算的

3.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)]

以下代码运行不少时间(近30分钟)

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')

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.197389	0.141478	0.168897	1001.733766	0.169990	0.141544
cv2	0.193758	0.191933	0.143521	0.171852	417.772333	0.171826	0.145501
cv3	0.194132	0.189844	0.141509	0.170875	966.174349	0.172123	0.143887
cv4	0.191825	0.189257	0.140547	0.169064	848.035829	0.169635	0.142497
cv5	0.195758	0.204853	0.146956	0.174094	637.565235	0.172824	0.144852

可以看到随机森林模型在每一个fold中均取得了更好的效果

4 模型调参

在此我们介绍了三种常用的调参方法如下：

贪心算法 https://www.jianshu.com/p/ab89df9759c8
网格调参 https://blog.csdn.net/weixin_43172660/article/details/83032029
贝叶斯调参 https://blog.csdn.net/linxid/article/details/81189154

## 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 = []

4.1 贪心调参

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

以下代码运行需近10分钟

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())])

4.2 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.1375483296069761

4.3 贝叶斯调参

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 |
-------------------------------------------------------------------------
|  1        |  0.8654   |  89.73    |  47.99    |  60.43    |  0.7737   |
|  2        |  0.8678   |  75.31    |  69.03    |  80.15    |  0.2702   |
|  3        |  0.8632   |  94.39    |  2.258    |  49.32    |  0.4728   |
|  4        |  0.869    |  68.66    |  17.74    |  97.14    |  0.8715   |
|  5        |  0.8655   |  56.37    |  3.616    |  61.22    |  0.6994   |
|  6        |  0.8253   |  3.894    |  94.83    |  99.25    |  0.658    |
|  7        |  0.8689   |  71.77    |  15.09    |  98.77    |  0.7976   |
|  8        |  0.8692   |  69.57    |  15.16    |  94.26    |  0.7235   |
|  9        |  0.8316   |  91.81    |  98.52    |  7.157    |  0.5052   |
|  10       |  0.8692   |  99.51    |  94.54    |  97.41    |  0.1907   |
|  11       |  0.802    |  3.35     |  5.347    |  3.041    |  0.3482   |
|  12       |  0.8692   |  98.16    |  2.966    |  98.44    |  0.3444   |
|  13       |  0.869    |  99.44    |  46.91    |  95.73    |  0.1742   |
|  14       |  0.8676   |  99.2     |  96.79    |  77.81    |  0.911    |
|  15       |  0.8679   |  83.65    |  2.167    |  81.08    |  0.13     |
|  16       |  0.8694   |  87.95    |  94.39    |  99.35    |  0.9643   |
|  17       |  0.8694   |  98.99    |  76.62    |  96.4     |  0.9981   |
|  18       |  0.8687   |  85.95    |  32.62    |  90.83    |  0.9919   |
|  19       |  0.8692   |  56.89    |  3.561    |  97.47    |  0.4441   |
|  20       |  0.869    |  80.05    |  2.333    |  96.68    |  0.756    |
|  21       |  0.8692   |  99.64    |  92.8     |  99.68    |  0.1351   |
|  22       |  0.8694   |  86.13    |  76.23    |  99.62    |  0.1235   |
|  23       |  0.8692   |  73.98    |  2.026    |  98.46    |  0.976    |
|  24       |  0.8694   |  99.32    |  67.72    |  99.3     |  0.9015   |
|  25       |  0.8687   |  91.35    |  65.16    |  95.7     |  0.1098   |
|  26       |  0.8686   |  71.23    |  2.493    |  91.41    |  0.9693   |
|  27       |  0.8695   |  98.48    |  96.81    |  99.2     |  0.7796   |
|  28       |  0.8679   |  73.98    |  2.711    |  86.58    |  0.1026   |
|  29       |  0.8694   |  86.68    |  67.38    |  99.53    |  0.9688   |
|  30       |  0.8691   |  99.13    |  99.51    |  97.62    |  0.7705   |
=========================================================================
'''

1 - rf_bo.max['target']
# 0.13051612046516825
# 第27号为最优参数

以下代码和图引自小雨姑娘

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])

学习问题与解答

问题1 ：简单建模后需要可视化所有特征吗

解答：先查看前3-5个权重的特征，可视频化后，查看预测值与真实值是否接近，是否出现异常情况，如出现负值等

问题2 ：调参神器贝叶斯优化（bayesian-optimization）

解答：
原理：利用已有的先验信息去找到使目标函数达到全局最大的参数。
贝叶斯调参相对于网格搜索的优势：
- 贝叶斯调参采用高斯过程，会考虑到之前的参数信息，不断地更新先验；网格搜索则不会考虑先验信息。
- 贝叶斯调参迭代次数少，速度快；网格搜索会遍历所有的可能的参数组合，所以速度慢,参数多时易导致维度爆炸
- 贝叶斯调参针对非凸问题依然稳健；网格搜索针对非凸问题易得到局部最优。
一旦出现更好的参数空间，会有通过不同颜色来区别。

学习思考与总结

通过各模型的比较，首先对各种模型的复杂度要有一个总体的了解，一般先复杂度低的模型，因为在调参过程是非常耗时间，较复杂的模型跑一次就得花10-20分钟时间，所以在调参过程，需要考虑时间成本，以及效率。
如果为了比赛，提高 0.01 ，多花30分种，那也是可以的。
贝叶斯调参是一种值得推荐的方法，充分利用已有的先验信息去找到使目标函数达到全局最大的参数，是一种逐步求精的方法。

cndrip

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
天池龙珠数据挖掘训练营 Task4 学习笔记（建模调参）

天池龙珠数据挖掘训练营学习笔记(4) --建模与调参本节介绍了简单建模的方法，查看模型的异常情况，进行优化和处理，通过交叉验证评估模型的符合情况；通过多种模型对比（包括线性与非线性），找出最佳模型；运用三种常用调参方法（贪心调参、网格搜索调参和贝叶斯调参）对模型进行，找出最优参数。
复制链接

扫一扫