微信号:shushuojun

介绍:数据分析师之家.旨在为数据人提供一个学习、分享、互帮互助的家园.

【吐血整理】一份完备的集成学习手册!(附Python代码)

2018-10-16 07:50 红色石头
来源: AI有道
原文作者:AISHWARYA SINGH
编译:红色石头
数说工作室授权转载



数说君推荐:
1、系统的总结了集成学习的内容,入门的话,基本上看这一篇就够了
2、讲解非常友好,透彻易懂
3、每段都附上了Python代码,而且是通过Sklearn库实现的,非常容易看懂



引言


试想一下,当你想买一辆新车时,你会直接走到第一家汽车商店,并根据经销商的建议购买一辆车吗?这显然不太可能。


你可能会浏览一些门户网站,在那里查看人们对于不同车型的比较和评论,了解它们的特点和价格。你也可能会向朋友和同事征求一下他们的意见。简而言之,你不会直接给出一个结论,而是会综合考虑其他人的意见再做出决定。


机器学习中的集成模型(Ensemble Models)采用了类似的思想。集成模型结合多个模型的决策,以提高整体性能。这可以通过多种方式来实现,本文将一一介绍。


本文的目的是介绍集成学习的概念,并理解使用这种技术的算法。为了加强您对不同算法的理解,我们将对实际问题的案例使用 Python 来解释这些高级算法。


注意:弄懂本文需要对机器学习算法有一个基本的了解,我建议你通过这篇文章来熟悉一些基本概念:


一份机器学习的自白书


目录:


  1. 集成学习简介

  2. 基本的集成技术

    2.1 最大化

  3. 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 test

from 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,  123410]),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,  123410]),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,它是一个整数,定义用于训练的随机种子。


结语


集合建模可以指数地提高模型的性能!在本文中,我们介绍了各种集成学习技术,并了解了这些技术在机器学习算法中的应用。此外,我们实现了我们的贷款预测数据集的算法。


这篇文章将使你对这个话题有一个全面的了解。此外,鼓励你自己动手实现这些算法并与我们分享你的结果!





BAT招聘:

蚂蚁金服招人啦!| Hey bro, 这份工作太skr




相关阅读:


从「获取数据」到「自动下单」 | 《数字货币量化投资课程》培训


量化投资之资本资产定价模型(CAPM)


class 类—老司机的必修课 | 统计师的Python日记 第11课


【争鸣!西方经济学流派图】


【文本处理系列】

1. 了解文本分析 | 余弦相似度思想

2. 尝试找出相似文本 | 词频与余弦相似度

3. 简化文本 | TF-IDF

4. 文本相似的其他衡量方法 | 常用距离/相似度 一览

5. 大规模文本处理(1) | 哈希函数

6. 大规模文本处理(2)| 海量文本用 Simhash, 2小时变4秒!


后台回复 SASRE 看SAS正则表达式系列;回复 SVM 看SVM系列。

 
数说工作室 更多文章 3行代码实现 Python 并行处理,速度提高6倍! 教你如何在放满假的情况下,还能比别人多出7天工作时间! 支付宝有多安全?看 ATEC 大会上这项技术就明白了 海量文本用 Simhash, 2小时变4秒! | 文本分析:大规模文本处理(2) Hey bro, 这份工作太skr | 蚂蚁金服招聘
猜您喜欢 少侠你骨骼惊奇,传你六招武林绝技! 儿童色情产业!直播、猥亵等视频,线下交易“男童2000元\/次” 【API经济前世今生四部曲】江湖动荡篇:“互联网+” 时代下的产业变革之道 从又拍云看云存储服务的可用性 Sublime Text奇技淫巧