【吐血整理】一份完备的集成学习手册!(附Python代码)
原文作者:AISHWARYA SINGH编译:红色石头
引言:
试想一下,当你想买一辆新车时,你会直接走到第一家汽车商店,并根据经销商的建议购买一辆车吗?这显然不太可能。
你可能会浏览一些门户网站,在那里查看人们对于不同车型的比较和评论,了解它们的特点和价格。你也可能会向朋友和同事征求一下他们的意见。简而言之,你不会直接给出一个结论,而是会综合考虑其他人的意见再做出决定。
机器学习中的集成模型(Ensemble Models)采用了类似的思想。集成模型结合多个模型的决策,以提高整体性能。这可以通过多种方式来实现,本文将一一介绍。
本文的目的是介绍集成学习的概念,并理解使用这种技术的算法。为了加强您对不同算法的理解,我们将对实际问题的案例使用 Python 来解释这些高级算法。
注意:弄懂本文需要对机器学习算法有一个基本的了解,我建议你通过这篇文章来熟悉一些基本概念:
一份机器学习的自白书
目录:
集成学习简介
基本的集成技术
2.1 最大化
2.2 平均化
2.3 加权平均
3. 高级集成技术
3.1 Stacking
3.2 Blending
3.3 Bagging
3.4 Boosting
4. 基于 Bagging 和 Boosting 的算法
4.1 Bagging meta-estimator
4.2 Random Forest
4.3 AdaBoost
4.4 GBM
4.5 XGB
4.6 Light GBM
4.7 CatBoost
1. 集成学习简介
让我们通过一个例子来理解集成学习的概念。假设你是一个电影导演,你对一个非常重要和有趣的话题都创作了一部电影短片。现在,你想在公映之前对这部电影进行初步的反馈(打分)。该怎么做呢?
A: 你可以咨询一个好朋友来对电影进行打分
这种方法完全有可能会出现一种情况,就是电影很糟糕,但是你的好朋友不忍心伤你的心,因此不会打一星。
B: 你可以咨询 5 位同事来对电影进行打分
这种方法要好些,可以为你的电影提供较诚实的评价。但问题依然存在,这 5 个人可能不是该电影主题的专家,虽然他们可能知道摄影、镜头、音频等一些电影知识。
C: 你可以咨询 50 个人来对电影进行打分
其中一些可能是你的朋友,有些可能是你的同事,有些甚至可能是陌生人。
这种打分方法,反应会更加普遍和多样化,因为打分的人更多更多样了。事实证明,相比 A 和 B,C 更加科学。
通过这些例子,你可以推断出相比一个人的意见,综合多个人的意见可能做出更好的决定。这个例子对于多模型和单模型的比较也是成立的。机器学习中的这种多样化是通过一种称为集成学习的技术实现的。
现在,你已经掌握了集成学习的要点。接下来让我们看看集成学习中的各种技术及其实现方法。
2. 基本的集成技术
在本节中,我们将介绍一些简单但功能强大的技术:
最大化
平均化
加权平均
2.1 最大化
最大化通常用于分类问题。这种技术,所有模型都对该实例进行预测,每个模型的预测都可以看成是一次投票。获得投票数最多的那一类别就是最终的预测结果。
例如刚才的例子,5 个同事给你的电影打分,其中 3 人打了 5 星,2 人打了 4 星。则根据最大化原则,打 5 星的人数更多,最终判断电影评分为 5 星。
示例代码:
model1 = tree.DecisionTreeClassifier()
model2 = KNeighborsClassifier()
model3= LogisticRegression()model1.fit(x_train,y_train)
model2.fit(x_train,y_train)
model3.fit(x_train,y_train)pred1=model1.predict(x_test)
pred2=model2.predict(x_test)
pred3=model3.predict(x_test)final_pred = np.array([])
for i in range(0,len(x_test)):final_pred = np.append(final_pred, mode([pred1[i], pred2[i], pred3[i]]))
或者,你也可以使用 sklearn 库中的 VotingClassifier:
from sklearn.ensemble import VotingClassifier
model1 = LogisticRegression(random_state=1)
model2 = tree.DecisionTreeClassifier(random_state=1)
model = VotingClassifier(estimators=[('lr', model1), ('dt', model2)], voting='hard')
model.fit(x_train,y_train)
model.score(x_test,y_test)
2.2 平均化
类似于最大化投票方法,平均化的做法就是对所有的预测结果求平均值,平均值作为最后的预测结果。平均化可以应用于回归问题的预测或者在分类问题中计算概率值。
还是刚才的例子,5 个同事给你的电影打分,其中 3 人打了 5 星,2 人打了 4 星。则根据平均化原则,计算最终打分为:
(5 + 5 + 5 + 4 + 4) / 5 = 4.6
示例代码:
model1 = tree.DecisionTreeClassifier()
model2 = KNeighborsClassifier()
model3= LogisticRegression()model1.fit(x_train,y_train)
model2.fit(x_train,y_train)
model3.fit(x_train,y_train)pred1=model1.predict_proba(x_test)
pred2=model2.predict_proba(x_test)
pred3=model3.predict_proba(x_test)finalpred=(pred1+pred2+pred3)/3
2.3 加权平均
这是平均化方法的一个扩展,所有的模型被赋予不同的权重(定义为在预测中不同模型所占的重要性)。例如,如果你的两个同事在这方面比较专业,那么他们两人的意见所占的比重就更大一些。假设这两人占的比重均为 0.23,其他三人占的比重均为 0.18,则加权平均后的结果为:
5*0.23 + 4*0.23 + 5*0.18 + 4*0.18 + 4*0.18 = 4.41
示例代码:
model1 = tree.DecisionTreeClassifier()
model2 = KNeighborsClassifier()
model3= LogisticRegression()model1.fit(x_train,y_train)
model2.fit(x_train,y_train)
model3.fit(x_train,y_train)pred1=model1.predict_proba(x_test)
pred2=model2.predict_proba(x_test)
pred3=model3.predict_proba(x_test)finalpred=(pred1*0.3+pred2*0.3+pred3*0.4)
3. 高级集成技术
上文我们已经了解了基本的集成技术,接下来将介绍一下高级的集成技术。
3.1 Stacking
Stacking 是使用多个模型(例如决策树、KNN、SVM)来构建新的模型的集成技术。该模型在测试集上进行预测。下面是一个简单的 Stacking 集成的详细步骤解释。
1)将训练集划分为 10 个子集。
2)在其中 9 个子集上训练一个基本模型(例如决策树模型),在第 10 个子集上进行测试。遍历每个子集,重复进行 10 次。得到的 DT 长度与 Train set 相同。
3)在整个训练集上使用该模型(决策树)进行建模。
4)使用建模的模型在测试集上进行测试。
5)使用另一种算法(例如 knn),重复步骤 2~4,作用在 Train set 和 Test set 上,得到另一组值。
6)使用得到的 DT 和 knn 组合作为新的特征 TRAIN PREDICTION SET,训练新的模型(例如逻辑回归)。
7)使用训练好的模型对 TEST PREDICTION SET 进行预测。
示例代码:
首先,我们需要定义一个函数对 n 折训练集和测试集进行预测,该函数返回每个模型对训练集和测试集的预测结果。
def Stacking(model,train,y,test,n_fold):folds=StratifiedKFold(n_splits=n_fold,random_state=1)test_pred=np.empty((test.shape[0],1),float)train_pred=np.empty((0,1),float)for train_indices,val_indices in folds.split(train,y.values):x_train,x_val=train.iloc[train_indices],train.iloc[val_indices]y_train,y_val=y.iloc[train_indices],y.iloc[val_indices]model.fit(X=x_train,y=y_train)train_pred=np.append(train_pred,model.predict(x_val))test_pred=np.append(test_pred,model.predict(test))return test_pred.reshape(-1,1),train_pred
然后,我们构建两个基本模型:决策树和 knn。
model1 = tree.DecisionTreeClassifier(random_state=1)test_pred1 ,train_pred1=Stacking(model=model1,n_fold=10, train=x_train,test=x_test,y=y_train)train_pred1=pd.DataFrame(train_pred1)
test_pred1=pd.DataFrame(test_pred1)
model2 = KNeighborsClassifier()test_pred2 ,train_pred2=Stacking(model=model2,n_fold=10,train=x_train,test=x_test,y=y_train)train_pred2=pd.DataFrame(train_pred2)
test_pred2=pd.DataFrame(test_pred2)
最后,使用逻辑回归,进行训练和预测。
df = pd.concat([train_pred1, train_pred2], axis=1)
df_test = pd.concat([test_pred1, test_pred2], axis=1)model = LogisticRegression(random_state=1)
model.fit(df,y_train)
model.score(df_test, y_test)
为了将问题简单化,我们所创建的 Stacking 模型只有两层。第一层是建立决策树和 knn 模型,第二层是建立逻辑回归模型。实际应用中可以使用多个层次的复杂结构。
3.2 Blending
Blending 与 Stacking 类似,但是仅从训练集上划分一部分作为 holdout(验证集),没有使用 k 折验证。Holdout 集结果作为下一层的训练数据。下面是 Blending 的详细步骤解释。
1)将所有的训练数据划分为训练集和验证集。
2)在训练集上训练模型。
3)在验证集和整体测试集上进行模型测试。
4)验证集和测试结果作为元特征,进行第二层的模型训练。
5)使用该模型在整体测试集的元特征上进行模型验证。
示例代码:
首先,我们在训练集上训练两个模型:决策树和 knn,以便在验证集上作出预测。
model1 = tree.DecisionTreeClassifier()
model1.fit(x_train, y_train)
val_pred1=model1.predict(x_val)
test_pred1=model1.predict(x_test)
val_pred1=pd.DataFrame(val_pred1)
test_pred1=pd.DataFrame(test_pred1)model2 = KNeighborsClassifier()
model2.fit(x_train,y_train)
val_pred2=model2.predict(x_val)
test_pred2=model2.predict(x_test)
val_pred2=pd.DataFrame(val_pred2)
test_pred2=pd.DataFrame(test_pred2)
然后,结合验证集的元特征,训练逻辑回归模型,在测试集上进行验证。
df_val=pd.concat([x_val, val_pred1,val_pred2],axis=1)
df_test=pd.concat([x_test, test_pred1,test_pred2],axis=1)model = LogisticRegression()
model.fit(df_val,y_val)
model.score(df_test,y_test)
3.3 Bagging
Bagging 背后的思想就是将多个模型(例如决策树)的结果结合得到泛化的结果。这里有一个问题:在同样的数据集上训练得到不同的模型有用吗?有很大几率这些模型将给出同样的结果,因为它们的输入都是一致的。因此,如何解决这一问题呢?常用的方法就是 Bootstrapping。
Bootstrapping 是一种采样技术,从原始数据集中有放回地采样,创建观测子集。子集的大小与原始集合的大小相同。
Bagging(Bootstrap Aggregating)技术使用这些子集(bags)来得到一个相对公平的分布(完全集)。子集的大小也可能少于原始集。
1)从原始数据集中创建多个子集,有放回地进行采样。
2)在每个子集上训练一个基本模型(弱模型)。
3)这些模型相互平行且独立。
4)最后的预测结果由所有模型共同决定。
3.4 Boosting
在我们进一步讨论之前,还有一个问题:如果一个数据点被第一个模型预测错误,那么下一个模型(可能是所有的模型)组合预测会预测正确吗?这样的情况可以通过 boosting 来处理。
Boosting 是一个循序渐进的过程,其中每一个后续模型都试图纠正前一个模型的错误。后一个模型依赖于先前的模型。下面让我们来了解 Boosting 的工作方式。
1)从原始数据集中创建一个子集。
2)起始状态,所有数据点都赋予相同的权重。
3)在这个子集上训练一个基本模型。
4)使用该模型在整个数据集上进行预测。
5)根据实际值和预测值计算误差。
6)对预测错误的数据点给予更高的权重(如上图中预测错误的蓝色的“+”将赋予更大的权重)。
7)在此数据集上训练一个新的模型并预测(该模型试图纠正上一个模型中的错误点)。
8)类似地创建多个模型,每个模型校正前一个模型的错误。
9)最终的模型(强学习器)是所有模型(弱学习器)的加权平均。
因此,Boosting 算法结合了一些弱学习器,形成一个强大的学习器。单个模型在整个数据集上表现不好,但是它们在部分数据集上可能表现得很好。因此,每个模型实际上提升了集合的性能。
4. 基于 Bagging 和 Boosting 的算法
Bagging 和 Boosting 是机器学习中最常用的两种技术。在这一节中,我们将详细地研究它们。以下是我们将重点研究的算法:
Bagging 算法:
Bagging 元估计
随机森林
Boosting 算法:
AdaBoost
GBM
XGBM
Light
GBM
CatBoost
或者在本节中讨论的所有算法,我们将遵循这个过程:
算法介绍
示例代码
参数
这篇文章中,我将讨论贷款预测问题。您可以从这里下载数据集:
https://datahack.analyticsvidhya.com/contest/practice-problem-loan-prediction-iii/
请注意,对于每个算法,一些代码(读取数据、分割训练集、测试集等)是相同的。为了避免重复,我已经在下面写下这些相同的代码,之后只会深入讨论算法的核心代码。
#importing important packages
import pandas as pd
import numpy as np#reading the dataset
df=pd.read_csv("/home/user/Desktop/train.csv")#filling missing values
df['Gender'].fillna('Male', inplace=True)
类似地,关于数据填充、缺失值、异常值的处理,本文不做具体介绍。可参阅这篇文章了解相关内容:
https://www.analyticsvidhya.com/blog/2015/04/comprehensive-guide-data-exploration-sas-using-python-numpy-scipy-matplotlib-pandas/
#split dataset into train and testfrom sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.3, random_state=0)x_train=train.drop('Loan_Status',axis=1)
y_train=train['Loan_Status']x_test=test.drop('Loan_Status',axis=1)
y_test=test['Loan_Status']#create dummies
x_train=pd.get_dummies(x_train)
x_test=pd.get_dummies(x_test)
接下来,让我们开始 Bagging 和 Boosting 算法吧!
4.1 Bagging 元估计
Bagging 元估计是一种集成算法,可用于分类(BaggingClassifier)和回归(BaggingRegressor)问题。它遵循典型的 Bagging 技术进行预测。下面是 Bagging 元估计算法的步骤:
1)从原始数据集中创建随机子集(Bootstrapping)。
2)子集包含所有特征。
3)用户指定的基本估计器在这些子集上进行训练。
4)每个模型的预测结合形成最终的结果。
代码:
from sklearn.ensemble import BaggingClassifier
from sklearn import tree
model = BaggingClassifier(tree.DecisionTreeClassifier(random_state=1))
model.fit(x_train, y_train)
model.score(x_test,y_test)
0.75135135135135134
对于回归问题:
from sklearn.ensemble import BaggingRegressor
model = BaggingRegressor(tree.DecisionTreeRegressor(random_state=1))
model.fit(x_train, y_train)
model.score(x_test,y_test)
参数:
base_estimator:
它定义了基本的学习器,缺失时默认使用决策树。
n_estimators:
它定义基本学习器的数量。学习器数量需要选择合适的值,太大影响训练速度,太小影响训练精度。
max_samples:
每个子集最大样本数量。
max_features:
每个子集最大特征数量。
n_jobs:
并行运行的任务数量。将该值设置为与系统中的内核相等。 如果设置为 -1,任务数量等于内核数。
random_state:
它指定了随机划分的方法。当两个模型的随机状态值相同时,它们的随机选择相同。比较不同的模型时,这个参数是有用的。
4.2 随机森林
随机森林遵循 Bagging 技术的另一种集成机器学习算法。它是 Bagging 估计算法的一个扩展。随机森林中的基本学习器是决策树。与 Bagging 元估计不同,随机森林随机选择一组特征,这些特征用于在决策树的每个节点处决定最佳分割。
随机森林算法的详细步骤如下:
1)从原始数据集中创建随机子集(Bootstrapping)。
2)在决策树中的每个节点,使用随机特征来决定最佳分割。
3)在每个子集上训练一个决策树模型。
4)最后的结果是对所有决策树的预测计算平均值。
注:随机森林中的决策树可以建立在数据和特征的子集上。特别地,sklearn 中的随机森林模型将所有特征用于决策树,并且随机选择特征子集用于在每个节点处分割。
总之,随机森林随机选择数据点和特征,并建立多个树木(森林)。
代码:
from sklearn.ensemble import RandomForestClassifier
model= RandomForestClassifier(random_state=1)
model.fit(x_train, y_train)
model.score(x_test,y_test)
0.77297297297297296
你可以使用 model.feature_importances_ 来查看特征的重要性。
for i, j in sorted(zip(x_train.columns, model.feature_importances_)):print(i, j)
结果如下:
ApplicantIncome 0.180924483743
CoapplicantIncome 0.135979758733
Credit_History 0.186436670523
.
.
.
Property_Area_Urban 0.0167025290557
Self_Employed_No 0.0165385567137
Self_Employed_Yes 0.0134763695267
回归问题的示例代码:
from sklearn.ensemble import RandomForestRegressor
model= RandomForestRegressor()
model.fit(x_train, y_train)
model.score(x_test,y_test)
参数:
n_estimators:
它定义了在随机森林中创建的决策树的数量。一般来说,较多的决策树使预测更强、更稳定,但是过多会导致更长的训练时间。
criterion:
它定义了用于分裂的函数。该函数测量每个特征的分割质量,并选择最佳分割。
max_features :
它定义了每个决策树中分割所允许的最大特征数。增加其值通常会提高性能,但是过高会降低每颗树的多样性。
max_depth:
随机森林具有多个决策树。此参数定义树的最大深度。
min_samples_split:
定义叶节点分裂所需的最小样本数。如果样本数量小于改值,则节点不被拆分。
min_samples_leaf:
定义在叶节点上需要的最小样本数。较小的值使得模型更容易捕获训练数据中的噪声。
max_leaf_nodes:
此参数指定每个树的最大叶节点数。当叶节点的数量等于该值时,停止分裂。
n_jobs:
这指示并行运行的任务数量。如果您希望它在系统中的所有内核上运行,则将值设置为 -1。
random_state:
此参数用于定义随机选择。比较不同的模型时,这个参数是有用的。
4.3 AdaBoost
自适应 Boosting(AdaBoost)是最简单的 Boosting 算法之一。通常,决策树用于建模。顺序创建多个模型,每个模型校正前一个模型的错误。AdaBoost 为上一个模型中预测错误的数据点分配更大的权重,在此模型工作以便能够正确地预测。
下面是 AdaBoost 算法的步骤:
1)最初,对数据集中的所有数据点赋予相同的权重。
2)在数据子集上建立模型。
3)使用该模型,对整个数据集进行预测。
4)通过比较预测值和实际值来计算误差。
5)在创建下一个模型时,对预测不正确的数据点给出更高的权重。
6)可以使用误差值确定权重。例如,误差大的赋予更大的权重。
7)重复这个过程直到误差函数不改变,或者达到学习器的最大数量。
代码:
from sklearn.ensemble import AdaBoostClassifier
model = AdaBoostClassifier(random_state=1)
model.fit(x_train, y_train)
model.score(x_test,y_test)
0.81081081081081086
回归问题的示例代码:
from sklearn.ensemble import AdaBoostRegressor
model = AdaBoostRegressor()
model.fit(x_train, y_train)
model.score(x_test,y_test)
参数:
base_estimator:
它有助于指定基本估计器的类型,也就是说,被用作基础学习器的机器学习算法。
n_estimators:
它定义了基本学习器的数量。默认值为10,但应设置更大的值以获得更好的性能。
learning_rate:
该参数控制最终组合中学习的贡献率。learning_rate 和 n_estimators 之间需要权衡。
max_depth:
定义单个估计器的最大深度。调整此参数以获得最佳性能。
n_jobs:
指定允许使用的处理器的数量。设置为 -1 时允许使用所有的处理器。
random_state:
它指定了随机划分的方法。如果给定相同的参数和训练数据,相同的 random_state 值总会产生相同的结果。
4.4 Gradient Boosting (GBM)
梯度提升(GBM)是另一种集成机器学习算法,它同时适用于回归和分类问题。GBM 使用提升技术,结合一些弱学习器形成一个强大的学习器。回归树作为基础学习器,每个后续的树是建立在由前一棵树计算的误差上的。
我们将使用一个简单的例子来理解 GBM 算法。使用以下数据来预测一组人的年龄:
1)平均年龄被假定为在数据集中的所有观察值的预测值。
2)使用该平均预测值和实际年龄值计算误差。
3)使用上面计算的误差作为目标变量创建树模型。我们的目标是找到最佳的分割,以尽量减少误差。
4)该模型的预测结果与 predicion1 相结合。
5)上面计算的值就是新的预测值。
6)利用该预测值和实际值计算新的误差。
7)重复步骤2到6直到达到最大迭代次数(或者误差函数不改变)。
代码:
from sklearn.ensemble import GradientBoostingClassifier
model= GradientBoostingClassifier(learning_rate=0.01,random_state=1)
model.fit(x_train, y_train)
model.score(x_test,y_test)
0.81621621621621621
回归问题的示例代码:
from sklearn.ensemble import GradientBoostingRegressor
model= GradientBoostingRegressor()
model.fit(x_train, y_train)
model.score(x_test,y_test)
参数:
min_samples_split:
定义在节点中用于分裂的样本(或观测)的最小数目,用于控制过拟合。更高的值可以阻止模型对树选择的特定样本具有高度特异性的关系。
min_samples_leaf:
定义终端或叶节点所需的最少样本。一般来说,对于不平衡的类问题,应该选择较小的值,因为少数类居多的区域将会比较小。
min_weight_fraction_leaf:
类似于 min_samples_leaf,但定义为占所有样本点的分数大小,而不是整数。
max_depth:
树的最大深度。用于控制过拟合,因为更高的深度可能使得模型学习特定于某些样本之间的关系。应该使用 CV 调试选择最佳深度。
max_leaf_nodes:
树中的终端节点或叶子的最大数目。可以用 max_depth 定义。由于创建二叉树,N 的深度会产生最多 2 的 N 次方的叶子。如果定义了这一参数,GBM 可以忽略 max_depth。
max_features:
在寻找最佳分割时要考虑的特征数量,一般是随机选择的。作为一个经验法则,取特征总数平方根数量的特征效果不错,但是我们一般选择总特征数的 30-40%。较高的值可能导致过拟合,但一般视情况而定。
4.5 XGBoost
XGBoost(extreme Gradient Boosting)是一种先进的梯度提升算法的实现。XGBoost 已被证明是一种高效的 ML 算法,广泛应用于机器学习竞赛中。XGBoost 具有较高的预测能力,比其他梯度提升技术速度快 10 倍。它还包括各种正则化技术减少过拟合来提高整体性能。因此,它也被称为“regularized boosting”技术。
让我们看看 XGBoost 是如何比其他技术更好的:
1)正则化
标准 GBM 没有像 XGBoost 那样的正则化。因此 XGBoost 有助于减少过拟合。
2)并行处理
XGBoost 实现并行处理,并且比 GBM 更快。XGBoost 还支持在 Hadoop 上实现。
3)高灵活性
XGBoost 允许用户自定义优化目标和评价标准,为模型添加一个新的维度。
4)处理缺失值
XGBoost 有一个内置功能来处理缺失值。
5)树修剪
XGBoost 进行分割到最大深度后,然后开始由下到上修剪树,移除没有正增益的分割。
6)内建交叉验证
XGBoost 允许用户在提升过程的每次迭代中运行交叉验证,因此很容易在一次运行中获得最佳提升迭代次数。
代码:
由于 XGBoost 可以处理缺失值,所以不必在预处理中对缺失值进行填充。你可以跳过上述代码中缺失值的填补步骤。按照其余的步骤进行:
import xgboost as xgb
model=xgb.XGBClassifier(random_state=1,learning_rate=0.01)
model.fit(x_train, y_train)
model.score(x_test,y_test)
0.82702702702702702
回归问题的示例代码:
import xgboost as xgb
model=xgb.XGBRegressor()
model.fit(x_train, y_train)
model.score(x_test,y_test)
参数:
nthread:
用于并行处理和系统中的允许使用的内核数量。如果希望在所有内核上运行,请不要输入此值,该算法将自动检测。
eta:
类似于 GBM 中的学习速率。通过缩小每个步骤的权重使模型更加健壮。
min_child_weight:
定义子节点样本点所需的最小加权和。用于控制过拟合。更高的值可以阻止模型对树选择的特定样本具有高度特异性的关系。
max_depth:
定义最大深度。更高的深度可能使得模型学习特定于某些样本之间的关系。
max_leaf_nodes:
树中的终端节点或叶子的最大数目。可以用 max_depth 定义。由于创建二叉树,N 的深度会产生最多 2 的 N 次方的叶子。如果定义了这一参数,GBM 可以忽略 max_depth。
gamma:
只有当分裂节点能减小损失函数一定值的时候,才分裂一个节点。参数 gamma 指定了分裂所需的损失函数减少的最小值。使得算法保守,gamma 可以根据损失函数而变化,并且应该调试。
subsample:
与 GBM 的 subsample 相同。表示每个树随机采样的数据点的分数。较低的值使算法更保守,并防止过拟合,但值太小可能导致欠拟合。
colsample_bytree:
它与 GBM 中的 max_features 特征相似。表示要为每个树随机抽样的列的分数。
4.6 LightGBM
在讨论 LightGBM 如何工作之前,让我们先了解为什么需要这个算法。我们已经有这么多 Boosting 算法了(如上面介绍的),当数据集非常大时,Light GBM 则优于其它所有的算法。与其他算法相比,Light GBM 在巨大的数据集上运行所消耗的时间更少。
LightGBM 是一个梯度增强框架,它使用基于树的算法,并遵循 leaf-wise 方式,而其他算法以 level-wise 方式工作。下面的图片将帮助你更好地理解差异。
level-wise 在数据量少的时候可能会导致过拟合,但是可以通过使用参数 max_depth 可以避免这种情况发生。你可以阅读下面的文章了解更多 Light GBM 及其与 XGB 的比较:
https://www.analyticsvidhya.com/blog/2017/06/which-algorithm-takes-the-crown-light-gbm-vs-xgboost/
代码:
import lightgbm as lgb
train_data=lgb.Dataset(x_train,label=y_train)
#define parameters
params = {'learning_rate':0.001}
model= lgb.train(params, train_data, 100)
y_pred=model.predict(x_test)
for i in range(0,185):if y_pred[i]>=0.5: y_pred[i]=1
else: y_pred[i]=0
0.81621621621621621
回归问题的示例代码:
import lightgbm as lgb
train_data=lgb.Dataset(x_train,label=y_train)
params = {'learning_rate':0.001}
model= lgb.train(params, train_data, 100)
from sklearn.metrics import mean_squared_error
rmse=mean_squared_error(y_pred,y_test)**0.5
参数:
num_iterations:
它定义要执行的 boosting 迭代数。
num_leaves:
此参数用于设置树中要形成的叶子的数量。对于 Light GBM,由于分裂发生在 level-wise 方向而不是 depth-wise 方向,所以num_leaft必须小于 2 的 max_depth 次方,否则可能导致过拟合。
min_data_in_leaf:
该值过小可能导致过度拟合。它也是处理过拟合的最重要的参数之一。
max_depth:
定义树可以生长的最大深度或高度。这个参数过大会导致过拟合。
bagging_fraction:
它用于指定每次迭代要使用的数据比例。这个参数通常用于加速训练。
max_bin:
定义特征值将被插入的容器的最大数目。较小的 max_bin 值可以节省大量时间,因为它将特征值存储到离散的容器中,计算代价小。
4.7 CatBoost
处理分类变量是一个乏味的过程,尤其有大量这样的变量。当分类变量的标签太多(例如高度基数)时,对它们进行独热编码会指数地增加维度,这让数据处理非常困难。
CatBoost 可以自动处理分类变量,并且不需要像其他机器学习算法那样进行额外的数据预处理。下面是一篇详细介绍 CatBoost 的文章:
https://www.analyticsvidhya.com/blog/2017/08/catboost-automated-categorical-data/
代码:
CatBoost 算法能有效地处理分类变量。因此,不需要对分类变量进行独热编码。只需加载文件,填入缺失值,就可以了。
from catboost import CatBoostClassifier
model=CatBoostClassifier()
categorical_features_indices = np.where(df.dtypes != np.float)[0]
model.fit(x_train,y_train,cat_features=([ 0, 1, 2, 3, 4, 10]),eval_set=(x_test, y_test))
model.score(x_test,y_test)
0.80540540540540539
回归问题的示例代码:
from catboost import CatBoostRegressor
model=CatBoostRegressor()
categorical_features_indices = np.where(df.dtypes != np.float)[0]
model.fit(x_train,y_train,cat_features=([ 0, 1, 2, 3, 4, 10]),eval_set=(x_test, y_test))
model.score(x_test,y_test)
参数:
loss_function:
定义用于训练的指标。
iterations:
可以生成的树的最大数量。最终树的数量可以小于或等于这个数。
learning_rate:
定义学习率,用于梯度下降优化中。
border_count:
它指定了数值特征的分裂数,类似于参数 max_bin。
depth:
定义树的深度。
random_seed:
这个参数类似于我们先前看到的参数 random_state,它是一个整数,定义用于训练的随机种子。
结语
集合建模可以指数地提高模型的性能!在本文中,我们介绍了各种集成学习技术,并了解了这些技术在机器学习算法中的应用。此外,我们实现了我们的贷款预测数据集的算法。
这篇文章将使你对这个话题有一个全面的了解。此外,鼓励你自己动手实现这些算法并与我们分享你的结果!
【推荐阅读】
吴恩达《Machine Learning Yearning》完结!
我的深度学习入门路线
【干货】我的机器学习入门路线图
【吐血整理】一份完备的集成学习手册!(附Python代码)相关推荐
- matlab中存档算法代码,MATLAB 智能算法超级学习手册中程序代码
[实例简介] MATLAB 智能算法超级学习手册中程序代码 [实例截图] [核心代码] dc90ef43-7920-434e-bdb8-0636c31c0b44 └── MATLAB 智能算法超级学习 ...
- LBP特征学习(附python实现)
LBP特征学习(附python实现) LBP的全称是Local Binary Pattern即局部二值模式,是局部信息提取中的一种方法,它具有旋转不变性和灰度不变性等显著的优点.在人脸识别领域有很多案 ...
- 独家 | 从基础到实现:集成学习综合教程(附Python代码)
作者:AISHWARYA SINGH 翻译:和中华 校对:丁楠雅 本文约8000字,建议阅读10+分钟. 本文从基础集成技术讲起,随后介绍了高级的集成技术,最后特别介绍了一些流行的基于Bagging和 ...
- python学习手册条件-Python学习手册(第4版)pdf
Python学习手册(第4版) 内容简介 <Python学习手册(第4版)>学习Python的主要内建对象类型:数字.列表和字典.使用Python语句创建和处理对象,并且学习Python的 ...
- python代码库-吐血整理!绝不能错过的24个Python库
Python有以下三个特点: 易用性和灵活性 全行业高接受度:Python无疑是业界最流行的数据科学语言 用于数据科学的Python库的数量优势 事实上,由于Python库种类很多,要跟上其发展速度非 ...
- 独家 | ARIMA/Sarima与LSTM的时间序列数据集成学习(附链接)
作者:夏米莎·查特吉 Sharmistha Chatterjee 翻译:陈之炎 校对:吴金笛 本文约5500字,建议阅读10+分钟. 本文探讨了简单的ARIMA/Sarima与LSTM的时间序列数据集 ...
- 集成学习 Adaboost(python实现)
参考资料 理论原理部分参考刘建平老师的博客集成学习之Adaboost算法原理小结 算法参数选择与调整上参考刘建平老师的博客scikit-learn Adaboost类库使用小结 算法实现 导入包 im ...
- ARIMA/Sarima与LSTM的时间序列数据集成学习(附链接)
作者:夏米莎·查特吉 Sharmistha Chatterjee ;翻译:陈之炎;校对:吴金笛 本文约5500字,建议阅读10+分钟. 本文探讨了简单的ARIMA/Sarima与LSTM的时间序列数据 ...
- 集成学习-模型融合学习笔记(附Python代码)
1 集成学习概述 集成学习(Ensemble Learning)是一种能在各种的机器学习任务上提高准确率的强有力技术,其通过组合多个基分类器(base classifier)来完成学习任务.基分类器一 ...
- Python学习手册之Python介绍、基本语法(二)
在上一篇文章中,我们介绍了Python的一些基本语法,现在我们继续介绍剩下的Python基本语法.查看上一篇文章请点击:https://www.cnblogs.com/dustman/p/987193 ...
最新文章
- MM--发票校验 及基于采购订单的MIRO发票校验过程
- 异常的产生与传递 java
- ROS 教程之 navigation : 用 move_base 控制自己的机器人(2)
- e: 无法定位软件包_比Ctrl+c,ctrl+v还好用的复制粘贴:Ctrl+d ctrl+r ctrl+e等
- 百面机器学习—13.L1正则化与稀疏性
- 拓扑排序Topological Sorting
- 【转】linux常用命令
- 机器学习三剑客之Matplotlib
- linux修改数据库密码出现的问题吗,关于linux下mysql修改root密码时遇到的问题
- 使用VS2015编译OpenJDK8
- php html5 应用缓存,HTML5 应用程序缓存
- Hadoop安装部署
- Java基本语法格式
- 开关电源电压型与电流型控制
- 全方位指导手把手教你实现自定义Spring Boot的 Starter公社
- 计算机垃圾清理指令,win7电脑清理垃圾的运行命令代码是什么
- 巴西区域赛补题C. Creating Multiples —— 数学*
- Stream Collectors - filtering
- 如何分分钟成为Java嵌入式开发人员
- UnRaid硬件直通的n种正确姿势