一、建模与调参

1.线性回归模型

线性回归(Linear Regression)是利用称为线性回归方程的最小平方函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。
训练模型的过程其实就是根据训练集的这些(X,Y)样本来求出合适的权重w，然后对新的测试集X预测相应的Ytest，这个Ytest其实就是我们想要的答案。这就是这部分的逻辑。

# 导入之前处理好的数据（我之前数据特征工程这块做得不好，需要再过一遍相关知识）
data = pd.read_csv('./pre_data/pre_data.csv')
data.head()# 然后训练集和测试集分开
train = data[:train_data.shape[0]]
test = data[train_data.shape[0]:]    # 这个先不用# 选择那些数值型的数据特征
continue_fea = ['power', 'kilometer', 'v_2', 'v_3', 'v_4', 'v_5', 'v_6', 'v_10', 'v_11', 'v_12', 'v_14','v_std', 'fuelType_price_average', 'gearbox_std', 'bodyType_price_average', 'brand_price_average','used_time', 'estivalue_price_average', 'estivalueprice_std', 'estivalue_price_min']
train_x = train[continue_fea]
train_y = train_data['price']

建立模型如果用sklearn的话还是非常简单的，包括训练和预测。

from sklearn.linear_model import LinearRegressionmodel = LinearRegression(normalize=True)
model.fit(train_x, train_y)

"""查看训练的线性回归模型的截距(intercept)与权重(coef)"""
print('intercept: ' + str(model.intercept_))
sorted(dict(zip(continue_fea, model.coef_)).items(), key=lambda x: x[1], reverse=True)
##：上面这行代码sorted(d.items()为待排序对象, key=lambda x: x[1]是为了用前面对象的第二维数据即value的值进行排序, reverse=True倒序)，dict(zip()用于将两个可迭代对象中对应元素打包成一个个元组，然后返回这些元组组成的列表，dict进而把元组列表创建字典)## 结果：
intercept: -178881.74591832393
[('v_6', 482008.29891714785),('v_std', 23713.66414841167),('v_10', 7035.056136559963),('v_14', 1418.4037751433352),('used_time', 186.48306334062053),('power', 12.19202369791551),('estivalue_price_average', 0.4082359327905722),('brand_price_average', 0.38196351334425965),('gearbox_std', 0.1716754674248321),('fuelType_price_average', 0.023785798378739224),('estivalueprice_std', -0.016868767797045624),('bodyType_price_average', -0.21364358471329278),('kilometer', -155.11999534761347),('estivalue_price_min', -574.6952072539285),('v_11', -1164.0263997737668),('v_12', -1953.0558048250668),('v_4', -2198.03802357537),('v_3', -3811.7514971187525),('v_2', -5116.825271420712),('v_5', -447495.6394686485)]

上面的这些就是我们那个等式中每个x前面的系数， intercept这个代表那个b，我们上面说过了，有了系数，我们就可以对新的样本进行预测。预测也很简单，只需要

y_pred = model.predict(x_test)

在后面模型对比中会发现线性模型的效果不好，因为我们前面特征选择的时候也看到过了啊，并不是所有的数值特征都和price有相关关系啊，还有一些非线性关系吧，这些线性模型就捕捉不到了，并且一般线性模型喜欢那种归一化或者标准化的数据，导致和非线性模型的数据还得分开处理，所以这个比赛不会用到线性模型。
但是关于线性模型还有些好玩的东西我们得了解一下，比如从这些权重中如何看出哪个特征对线性模型来说更加重要些？这个其实我们看的是权重的绝对值，因为正相关和负相关都是相关，越大的说明那个特征对线性模型影响就越大。
通过作图我们发现数据的标签（price）呈现长尾分布，不利于我们的建模预测。原因是很多模型都假设数据误差项符合正态分布，而长尾分布的数据违背了这一假设。（如果误差项满足正态分布，Q-Q Plot里的散点会近似的落在一条直线上。若不满足正态分布，则散点会偏离该直线。）
所以，我们不妨取对数一下：

train_y_ln = np.log1p(train_y)#log1p=log(x+1),log实现正态分布，+1能够避免x很小的的问题。还原的话用expm1
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)])

2.1交叉验证

这个常用来做算法的评估，评估就是估计算法在预测新数据的时候能达到什么程度。
因为在实际的训练中，训练的结果对于训练集的拟合程度通常还是挺好的（初始条件敏感），但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练，而是分出一部分来（这一部分不参加训练）对训练集生成的参数进行测试，相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证（Cross Validation）。交叉验证中，比较常用的就是K折交叉验证了，它有效的避免过拟合,最后得到的结果也比较具有说服性所以我们重点来看看这一块。

K折交叉验证是将原始数据分成K组，将每个子集数据分别做一次验证集，其余的K-1组子集数据作为训练集，这样会得到K个模型，用这K个模型最终的验证集分类准确率的平均数，作为此K折交叉验证下分类器的性能指标。
我们训练集是150000个样本，我们假设做5折交叉验证的话，就是把这150000个样本分成5份，每份30000，训练模型的时候，我们选四份作为训练集训练模型，然后在另一份上进行预测得到一个结果。这样，这五份轮流着做一遍测试集的话正好就是循环了五轮，得到了五个结果，然后我们去平均即可。这样的好处就是防止模型更加偏向某份数据，也能看出是否模型存在过拟合。
交叉验证， sklearn中提供了一个函数，叫做cross_val_score，我们就是用这个函数实现交叉验证，函数具体的作用可以去查一下sklearn的官方文档。

from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error, make_scorerdef log_transfer(func):def wrapper(y, yhat):result = func(np.log(y), np.nan_to_num(np.log(yhat)))   # 这个是为了解决不合法的值的return resultreturn wrapper# 下面是交叉验证
scores = cross_val_score(model, X=train_x, y=train_y, verbose=1, cv=5, scoring=make_scorer(log_transfer(mean_absolute_error)))# 使用线性回归模型，对未处理标签的特征数据进行五折交叉验证（Error 1.36）
print('AVG:', np.mean(scores))# 对处理的标签交叉验证
scores = cross_val_score(model, X=train_x, y=train_y_ln, verbose=1, cv = 5, scoring=make_scorer(mean_absolute_error))
print('AVG:', np.mean(scores))# 输出五次的验证结果：
scores = pd.DataFrame(scores.reshape(1,-1))
scores.columns = ['cv' + str(x) for x in range(1, 6)]
scores.index = ['MAE']
scores

tips:reshape(1,-1)转换成1行，reshape(2,-1)转换成2行，reshape(-1,1)转换成1列
verbose表示是否打印，cv分割次数，scoring代表评估方法。

这就是k折交叉验证的思想和实现了，这里再多说一点，就是这种方式不适合处理时间序列，因为时间序列是有先后关系的，五折交叉验证在某些与时间相关的数据集上反而反映了不真实的情况。就拿这次比赛来说，通过2018年的二手车价格预测2017年的二手车价格，这显然是不合理的，因此我们还可以采用时间顺序对数据集进行分隔。

2.2 构建一个线下测试集

这里是简单的介绍一个小技巧吧，当然这里是针对这个比赛，因为有时候我们发现在本地上训练数据集得到的结果很好，但是放到线上进行测试的时候往往不是那么理想，这就意味着我们线下的训练有些过拟合了，而我们一般并不知道，毕竟对于线上的测试，我们并没有真实的标签对比不是吗？所以我们可以先构建一个线下的测试集。这个实操起来也很简单，就是我们有150000个样本，我们可以用100000个样本来做训练集，后面的50000做测试集，因为我们已经知道这50000个样本的真实标签，这样训练出来的模型我们就可以直接先测试一下泛化能力，对于后面的调参或者是模型的评估等感觉还是挺好用的。

# 导入数据
data = pd.read_csv('./pre_data/pre_data.csv')train = data[:train_data.shape[0]]
test = data[train_data.shape[0]:]    # 这个先不用# 选数据
X = train[:100000]
Y= train_data['price'][:100000]
Y_ln = np.log1p(Y)XTest = train[100000:]   # 模拟一个线下测试集， 看看模型的泛化能力
Ytrue = train_data['price'][100000:]

3. 评估算法模型的框架

模型选择的时候，可以根据我们数据的特征和优化目标先选出很多个模型作为备选，因为我们分析完数据不能立刻得出哪个算法对需要解决的问题更有效。
这是一个回归问题，我们肯定使用回归模型（Regressor系列），但是回归模型太多，我们又知道部分数据呈线性分布，线性回归算法和正则化的回归算法可能对解决问题比较有效，由于数据的离散化，通过决策树算法及相应的集成算法也一般会表现出色，所以我们可以锁定几个模型都尝试一下。
我一般习惯建立一个字典，把这些模型放到字典里面，然后分别进行交叉验证，可视化结果来判断哪个模型针对当前问题表现比较好，这样从这里面选出3-4个进行下面的环节，也就是模型的调参工作。这里给出一个我常用的一个评估算法模型的一个框架，在这里，采用10交叉验证来分离数据，通过绝对值误差来比较算法的准确度，误差越小，准确度越高。
由于这里面会用到线性的一些模型，所以这里会给出两个框架吧算是，一个是基于原始的数据，一个是基于正态的数据（这里利用了Pipeline自动处理流程），这两个框架都可以做迁移，用到别的选择模型的任务中。

num_folds = 10
seed = 7# 把所有模型写到一个字典中
models = {}
models['LR'] = LinearRegression()
models['Ridge'] = Ridge()
models['LASSO'] = Lasso()
models['DecisionTree'] = DecisionTreeRegressor()
models['RandomForest'] = RandomForestRegressor()
models['GradientBoosting'] = GradientBoostingRegressor()
models['XGB'] = XGBRegressor(n_estimators = 100, objective='reg:squarederror')
models['LGB'] = LGBMRegressor(n_estimators=100)
#models['SVR'] = SVR()   # 支持向量机运行不出来results = []
for key in models:kfold = KFold(n_splits=num_folds, random_state=seed)cv_result = cross_val_score(models[key], X, Y_ln, cv=kfold, scoring=make_scorer(mean_absolute_error))results.append(cv_result)print('%s: %f (%f)' % (key, cv_result.mean(), cv_result.std()))# 评估算法 --- 箱线图
fig1 = plt.figure(figsize=(15, 10))
fig1.suptitle('Algorithm Comparison')
ax = fig1.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(models.keys())
plt.show()## 结果：
LR: 0.192890 (0.001501)
Ridge: 0.196279 (0.001616)
LASSO: 0.515573 (0.003923)
DecisionTree: 0.190959 (0.002524)
RandomForest: 0.142333 (0.001489)
GradientBoosting: 0.178403 (0.001903)
XGB: 0.178492 (0.001441)
LGB: 0.147875 (0.001397)

我们这里希望mae越小越好，所以箱型图整体靠下，横线（min,max）靠下的好。

这样，各个模型的效果是不是就一目了然了呢？从上图可以发现，随机森林和LGB的效果还是好一些的，后面可以基于这两个进行调参，当然xgboost的效果可能由于参数的原因表现不是那么理想，这里也作为了我们调参备选。毕竟现在还是xgb和lgb的天下嘛
这个是没有调参的LGB:

model2 = LGBMRegressor(n_estimators=100)
model2.fit(X, Y_ln)
pred2 = model2.predict(XTest)
print("mae: ", mean_absolute_error(Ytrue, np.expm1(pred2)))# 结果：
mae:  713.9408513079144

下面再看一下baseline里面的那个LGB：

def bulid_modl_lgb(x_train, y_train):estimator = LGBMRegressor(num_leaves=127, n_estimators=150)param_grid = {'learning_rage': [0.01, 0.05, 0.1, 0.2]}gbm = GridSearchCV(estimator, param_grid)gbm.fit(x_train, y_train)return gbmmodel_lgb = bulid_modl_lgb(X, Y_ln)
val_lgb = model_lgb.predict(XTest)
MAE_lgb = mean_absolute_error(Ytrue, np.expm1(val_lgb))
print(MAE_lgb)## 结果：
591.4221480289154

所以调参还是很重要的。但是在调参之前，还是先给出另一个正态模板。

正态化数据？

在这里猜测也许因为原始数据中心不同特征属性的度量单位不一样，导致有的算法不是很好。接下来通过正态化，再次评估这些算法。
对数据正态化时，为了防止数据泄露，采用“Pipeline”来正态化数据和对模型进行评估

from sklearn.pipeline import Pipelinepipelines = {}
pipelines['ScalerLR'] = Pipeline([('Scaler', StandardScaler()), ('LR', LinearRegression())])
pipelines['ScalerRidge'] = Pipeline([('Scaler', StandardScaler()), ('Ridge', Ridge())])
pipelines['ScalerLasso'] = Pipeline([('Scaler', StandardScaler()), ('Lasso', Lasso())])
pipelines['ScalerTree'] = Pipeline([('Scaler', StandardScaler()), ('Tree', DecisionTreeRegressor())])
pipelines['ScalerForest'] = Pipeline([('Scaler', StandardScaler()), ('Forest', RandomForestRegressor())])
pipelines['ScalerGBDT'] = Pipeline([('Scaler', StandardScaler()), ('GBDT', GradientBoostingRegressor())])
pipelines['ScalerXGB'] = Pipeline([('Scaler', StandardScaler()), ('XGB', XGBRegressor(n_estimators = 100, objective='reg:squarederror'))])
pipelines['ScalerLGB'] = Pipeline([('Scaler', StandardScaler()), ('LGB', LGBMRegressor(n_estimators=100))])results = []
for key in pipelines:kfold = KFold(n_splits=num_folds, random_state=seed)cv_result = cross_val_score(pipelines[key], X, Y_ln, cv=kfold, scoring=make_scorer(mean_absolute_error))results.append(cv_result)print('%s: %f (%f)' % (key, cv_result.mean(), cv_result.std()))# 评估算法 --- 箱线图
fig2 = plt.figure(figsize=(15, 10))
fig2.suptitle('Algorithm Comparison')
ax = fig2.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(models.keys())

4. 模型的调参

同特征工程一样，模型参数调节也是一项非常繁琐但又非常重要的工作。

根据模型复杂程度的不同，需要调节的参数数量也不尽相同。简单如逻辑回归，需要调节的通常只有正则项系数C；复杂如随机森林，需要调节的变量会多出不少，最核心的如树的数量n_estimators，树的深度max_depth等等。参数越多，调参的难度自然也越来越大，因为参数间排列组合的可能性越来越多. 在训练样本比较少的情况下，sklearn的GridSearchCV是个不错的选择，可以帮助我们自动寻找指定范围内的最佳参数组合。但实际情况是，GridSearch通常需要的运行时间过长，长到我们不太能够忍受的程度。所以更多的时候需要我们自己手动先排除掉一部分数值，然后或自己组合不断的尝试和调整。

模型的调参这里，有三种方式：

贪心调参
网格搜索调参
贝叶斯调参

这里给出一个模型可调参数及范围选取的参考：

下面的实验，我是以LGB作为实验的，因为这里为了整理调参方式，其他的模型也都是这个思路，所以为了减少篇幅，只对LGB做的实验，还有个原因就是LGB会很快。如果是针对随机森林，下面的三种调参方式我一种也没有跑完，因为数据量太大，参数太多的原因吧。所以围绕着LGB试试看看下面的三种方式究竟有什么区别

objective = ['regression', 'regression_l1', 'mape', 'huber', 'fair']
num_leaves = [10, 55, 70, 100, 200]
max_depth = [ 10, 55, 70, 100, 200]
n_estimators = [200, 400, 800, 1000]
learning_rate =  [0.01, 0.05, 0.1, 0.2]

4. 1 贪心调参

拿当前对模型影响最大的参数调优，直到最优化；再拿下一个影响最大的参数调优，如此下去，直到所有的参数调整完毕。这个方法的缺点就是可能会调到局部最优而不是全局最优，但是省时间省力，巨大的优势面前，可以一试。

下面就拿这个比赛来看一下：

# 先建立一个参数字典
best_obj = dict()# 调objective
for obj in objective:model = LGBMRegressor(objective=obj)score = np.mean(cross_val_score(model, X, Y_ln, verbose=0, cv=5, scoring=make_scorer(mean_absolute_error)))best_obj[obj] = score# 上面调好之后，用上面的参数调num_leaves
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, Y_ln, verbose=0, cv=5, scoring=make_scorer(mean_absolute_error)))best_leaves[leaves] = score# 用上面两个最优参数调max_depth
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, Y_ln, verbose=0, cv=5, scoring=make_scorer(mean_absolute_error)))best_depth[depth] = score# 调n_estimators
best_nstimators = dict()
for nstimator in n_estimators: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=min(best_depth.items(), key=lambda x:x[1])[0],n_estimators=nstimator)score = np.mean(cross_val_score(model, X, Y_ln, verbose=0, cv=5, scoring=make_scorer(mean_absolute_error)))best_nstimators[nstimator] = score# 调learning_rate
best_lr = dict()
for lr in learning_rate: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=min(best_depth.items(), key=lambda x:x[1])[0],n_estimators=min(best_nstimators.items(), key=lambda x:x[1])[0],learning_rate=lr)score = np.mean(cross_val_score(model, X, Y_ln, verbose=0, cv=5, scoring=make_scorer(mean_absolute_error)))best_lr[lr] = score

上面的过程建议放在不同的cell里面运行.

4.2 GridSearchCV 调参

GridSearchCV，它存在的意义就是自动调参，只要把参数输进去，就能给出最优化的结果和参数。但是这个方法适合于小数据集，一旦数据的量级上去了，很难得出结果。这个在这里面优势不大，因为数据集很大，不太能跑出结果，但是也整理一下，有时候还是很好用的。

from sklearn.model_selection import GridSearchCV# 这个我这边电脑运行时间太长，先不跑了,因为我设置的分类器的个数有点多了。
parameters = {'objective':objective, 'num_leaves':num_leaves, 'max_depth':max_depth,'n_estimators': n_estimators, 'learning_rate':learning_rate}model = LGBMRegressor()
clf = GridSearchCV(model, parameters, cv=5)
clf = clf.fit(X, Y_ln)# 输出最优参数

4.3 贝叶斯调参

这个需要安装个包： pip install bayesian-optimization

贝叶斯优化用于机器学习调参，主要思想是，给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。

与常规的网格搜索或者随机搜索的区别是：

贝叶斯调参采用高斯过程，考虑之前的参数信息，不断地更新先验；网格搜索未考虑之前的参数信息
贝叶斯调参迭代次数少，速度快；网格搜索速度慢,参数多时易导致维度爆炸
贝叶斯调参针对非凸问题依然稳健；网格搜索针对非凸问题易得到局部最优
使用方法：

定义优化函数(rf_cv, 在里面把优化的参数传入，然后建立模型，返回要优化的分数指标)
定义优化参数
开始优化（最大化分数还是最小化分数等）
得到优化结果

from  bayes_opt import BayesianOptimization# 定义优化函数
def rf_cv(num_leaves, max_depth, subsample, min_child_samples):model = LGBMRegressor(objective='regression_l1', num_leaves=int(num_leaves),max_depth=int(max_depth), subsample=subsample,min_child_samples = int(min_child_samples))val = cross_val_score(model, X, 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)}
)#开始优化
num_iter = 25
init_points = 5
rf_bo.maximize(init_points=init_points,n_iter=num_iter)#显示优化结果
rf_bo.res["max"]#附近搜索（已经有不错的参数值的时候）
rf_bo.explore({'n_estimators': [10, 100, 200],'min_samples_split': [2, 10, 20],'max_features': [0.1, 0.5, 0.9],'max_depth': [5, 10, 15]})

二、模型融合

是比赛后期一个重要的环节，大体来说有如下的类型方式。

简单加权融合:
回归（分类概率）：算术平均融合（Arithmetic mean），几何平均融合（Geometric mean）；
分类：投票（Voting)
综合：排序融合(Rank averaging)，log融合
stacking/blending:
构建多层模型，并利用预测结果再拟合预测。
boosting/bagging（在xgboost，Adaboost,GBDT中已经用到）:
多树的提升方法

什么是 stacking
简单来说 stacking 就是当用初始训练数据学习出若干个基学习器后，将这几个学习器的预测结果作为新的训练集，来学习一个新的学习器。

将个体学习器结合在一起的时候使用的方法叫做结合策略。对于分类问题，我们可以使用投票法来选择输出最多的类。对于回归问题，我们可以将分类器输出的结果求平均值。

上面说的投票法和平均法都是很有效的结合策略，还有一种结合策略是使用另外一个机器学习算法来将个体机器学习器的结果结合在一起，这个方法就是Stacking。

在stacking方法中，我们把个体学习器叫做初级学习器，用于结合的学习器叫做次级学习器或元学习器（meta-learner），次级学习器用于训练的数据叫做次级训练集。次级训练集是在训练集上用初级学习器得到的。
明天接着整理~自己的项目目前还有很多需要完善！参加Datawhale的活动时，真的需要自己提前做准备，要不然就会delay好多。
参考：https://tianchi.aliyun.com/notebook-ai/detail?spm=5176.12281978.0.0.6802593aj2t6aS&postId=95501
https://blog.csdn.net/wuzhongqiang/article/details/105012682

建模与调参+模型结果融合相关推荐

【算法竞赛学习】心跳信号分类预测-建模与调参
Task4 建模与调参此部分为零基础入门数据挖掘之心电图分类的 Task4 建模调参部分,带你来了解各种模型以及模型的评价和调参策略,欢迎大家后续多多交流. 赛题:零基础入门数据挖掘 - 心电图分类 ...
【算法竞赛学习】金融风控之贷款违约预测-建模与调参
Task4 建模与调参此部分为零基础入门金融风控的 Task4 建模调参部分,带你来了解各种模型以及模型的评价和调参策略,欢迎大家后续多多交流. 赛题:零基础入门数据挖掘 - 零基础入门金融风控之贷 ...
数据竞赛入门-金融风控（贷款违约预测）四、建模与调参
前言本次活动为datawhale与天池联合举办,为金融风控之贷款违约预测挑战赛(入门) 比赛地址:https://tianchi.aliyun.com/competition/entrance/53 ...
零基础入门金融风控-贷款违约预测-Task4 建模与调参
此部分为零基础入门金融风控的 Task4 建模调参部分,带你来了解各种模型以及模型的评价和调参策略,欢迎大家后续多多交流. 项目地址比赛地址 4.1 学习目标学习在金融分控领域常用的机器学习模型 ...
天池大赛-心跳信号分类预测：建模与调参
比赛地址:零基础入门数据挖掘-心跳信号分类预测参考资料:由DataWhale开源的学习资料 1 内容介绍逻辑回归模型: 理解逻辑回归模型: 逻辑回归模型的应用: 逻辑回归的优缺点: 树模型: 理解 ...
Datawhale 零基础入门数据挖掘- 建模与调参
Task4 建模与调参此部分为零基础入门数据挖掘之心电图分类的 Task4 建模调参部分,带你来了解各种模型以及模型的评价和调参策略,欢迎大家后续多多交流. 赛题:零基础入门数据挖掘 - 心电图分类 ...
Python机器学习建模的标准流程（特征工程+建模调参+模型评估+全流程可视化）
作者CSDN:进击的西西弗斯本文链接:https://blog.csdn.net/qq_42216093/article/details/116994199 版权声明:本文为作者原创文章,转载需征得 ...
数据挖掘-Task4：建模与调参
目录前言算法原理一.模型对比与性能评估 1.1 逻辑回归 1.2 决策树模型 1.3 模型评估的方法二.代码示例 2.1 导入相关包 2.2 读取数据 2.3 简单建模三.模型调参 3.1 ...
零基础入门数据挖掘：Task4 建模与调参
Stacking 简单来说 stacking 就是当用初始训练数据学习出若干个基学习器后,将这几个学习器的预测结果作为新的训练集,来学习一个新的学习器. 开始实践,总之先导入数据和库 import p ...

建模与调参+模型结果融合