集成学习

目录

 

定义

集成学习方法的一般过程描述

基础集成技术

集成学习方法

Bagging

Bagging算法流程

Boosting

Stacking

Blending

优点：

缺点：

随机森林

算法步骤：

影响随机森林分类性能的主要因素：

随机森林优缺点：

AdaBoost

GBDT

GBDT算法原理

gbdt+lr

XGBoost

---

定义

集成学习，顾名思义，通过将多个单个学习器集成/组合在一起，使它们共同完成学习任务，有时也被称为“多分类器系统（multi-classifier system）”、基于委员会的学习（Committee-based learning）

集成学习方法的一般过程描述

基础集成技术

最大投票法

平均法：对每个数据点的多次预测进行平均

加权平均法

集成学习方法

集成学习法(Ensemble learning)通过将多个分类学习方法聚集在一起来提高分类准确率。
– 通常一个集成分类器的分类性能会好于单个分类器。集成学习法由训练数据构建一组基分类器(base classifier)，然后通过对每个基分类器的预测进行投票来进行分类。
– 在构建分类器的过程中，一般有两种集成方法：
• 一种是使用训练集的不同子集训练得到不同的基分类器。
• 另一种方法是使用同一个训练集的不同属性子集训练得到不同的基分类器。

Bagging

基本思想：对训练集有放回地抽取训练样例，从而为每一个基本分类器都构造出一个跟训练集相当大小但各不相同的训练集，从而训练出不同的基本分类器；该算法是基于对训练集进行处理的集成方法中最简单、最直观的一种

Bagging要求“不稳定”的分类方法；比如：决策树，神经网络算法
• 不稳定：数据集的小的变动能够使得分类结果的显著的变动

Bagging算法流程

基本思想：对训练集有放回地抽取训练样例，从而为每一个基本分类器都构造出一个跟训练集相当大小但各不相同的训练集，从而训练出不同的基本分类器；该算法是基于对训练集进行处理的集成方法中最简单、最直观的一种

Bagging要求“不稳定”的分类方法；比如：决策树，神经网络算法
• 不稳定：数据集的小的变动能够使得分类结果的显著的变动

Bagging通过降低基分类器的方差改善了泛化误差。
• Bagging的性能依赖于基分类器的稳定性。
– 如果基分类器是不稳定的（比如：决策树，神经网络算法。），装袋有助于降低训练数据的随机波动导致的误差；
– 如果基分类器是稳定的（基分类器对训练数据集中的微小变化是鲁棒的），则集成分类器的误差主要是由基分类器的偏倚所引起的，bagging可能不会对基分类器的性能有明显改善。
– 另外由于每一个样本被选中的概率相同，因此装袋并不侧重于训练数据集中的任何特定实例。因此对于噪声数据，装袋不太受过分拟合的影响

Boosting

• Boosting是一个顺序过程，每个后续模型都会尝试纠正先前模型的错误。后续的模型依赖于之前的模型。
• 接下来一起看看boosting的工作方式：
第一步：从原始数据集创建一个子集。
第二步：最初，所有数据点都具有相同的权重。
第三步：在此子集上创建基础模型。
第四步：该模型用于对整个数据集进行预测。
第五步：使用实际值和预测值计算误差。
第六步：预测错误的点获得更高的权重。（这里，三个错误分类的蓝色加号点将被赋予更高的权重）

第七步：创建另一个模型并对数据集进行预测（此模型尝试更正先前模型中的错误）。

第八步：类似地，创建多个模型，每个模型校正先前模型的错误。
第九步：最终模型（强学习器）是所有模型（弱学习器）的加权平均值

因此，boosting算法结合了许多弱学习器来形成一个强学习器。单个模型在整个数据集上表现不佳，但它们在数据集的某些部分上表现很好。因此，每个模型实际上提升了集成的整体性能。

Boosting算法：首先给每一个训练样例赋予相同的权重，然后训练第一个基本分类器并用它来对训练集进行测试，对于那些分类错误的测试样例提高其权重（实际算法中是降低分类正确的样例的权重），然后用调整后的带权训练集训练第二个基本分类器，然后重复这个过程直到最后得到一个足够好的学习器

提升是一个迭代的过程，用于自适应地改变训练样本的分布，使得基分类器聚焦在那些很难分的样本上。不像装袋，提升给每一个训练样本赋予一个权值，而且可以在每一轮提升过程结束时自动地调整权值。训练样本的权值可以用于以下方面：
– (1)可以用作抽样分布，从原始数据集中提取出自主样本集；
– (2)基分类器可以使用权值学习有利于高权值样本的模型；

Bagging 和boosting的区别
• 训练集: – Bagging:随机选择,各轮训练集相互独立
               – Boosting:各轮训练集并不独立,它的选择与前轮的学习结果有关
• 预测函数: – Bagging:没有权重;可以并行生成
                   – Boosting:有权重;只能顺序生成

Stacking

最先想到的方法是这样的，

  1：用数据集D来训练h1,h2,h3...，

  2：用这些训练出来的初级学习器在数据集D上面进行预测得到次级训练集。

  3：用次级训练集来训练次级学习器。

  但是这样的实现是有很大的缺陷的。在原始数据集D上面训练的模型，然后用这些模型再D上面再进行预测得到的次级训练集肯定是非常好的。会出现过拟合的现象。

  那么，我们换一种做法，我们用交叉验证的思想来实现stacking的模型，从这里拿来一张图

 

  次级训练集的构成不是直接由模型在训练集D上面预测得到，而是使用交叉验证的方法，将训练集D分为k份，对于每一份，用剩余数据集训练模型，然后预测出这一份的结果。重复上面步骤，直到每一份都预测出来。这样就不会出现上面的过拟合这种情况。并且在构造次级训练集的过程当中，顺便把测试集的次级数据也给构造出来了。

  对于我们所有的初级训练器，都要重复上面的步骤，才构造出来最终的次级训练集和次级测试集。

Blending

Blending与Stacking大致相同，只是Blending的主要区别在于训练集不是通过K-Fold的CV策略来获得预测值从而生成第二阶段模型的特征，而是建立一个Holdout集，例如10%的训练数据，第二阶段的stacker模型就基于第一阶段模型对这10%训练数据的预测值进行拟合。说白了，就是把Stacking流程中的K-Fold CV 改成 HoldOut CV

优点：

1.比stacking简单（因为不用进行k次的交叉验证来获得stacker feature）

2.避开了一个信息泄露问题：generlizers和stacker使用了不一样的数据集

3.在团队建模过程中，不需要给队友分享自己的随机种子

缺点：

1.使用了很少的数据

2.blender可能会过拟合（其实大概率是第一点导致的）

3.stacking使用多次的CV会比较稳健

随机森林

随机森林（Random Forest，简称RF）是Bagging的一个扩展变体。RF在以决策树为基学习器构建Bagging集成的基础上，进一步在决策树的训练过程中引入了随机属性选择。
• 具体来说，传统决策树在选择划分属性时是在当前结点的属性集合（假定有d个属性）中选择一个最优属性；而在RF中，对基决策树的每个结点，先从该结点的属性集合中随机选择一个包含k个属性的子集，然后再从这个子集中选择一个最优属性用于划分。这里的参数k控制了随机性的引入程度：若令k=d，则基决策树的构建与传统决策树相同；若令k=1，则是随机选择一个属性用于划分

随机森林是一个树型分类器{h(x,bk),k=1,…}的集合。其中基分类器h(x,bk)是用CART算法构建的没有剪枝的分类回归树；
• 森林的输出采用简单多数投票法（针对分类）或单颗树输出结果的简单平均（针对回归）得到

算法步骤：

1. 随机选取训练样本集：使用Bagging方法形成每颗树的训练集；

2. 随机选取分裂属性集：假设共有M个属性，指定一个属性数F≤M，在每个内部结点，从M个属性中随机抽取F个属性作分裂属性集，以这F个属性上最好的分裂方式对结点进行分裂（在整个森林的生长过程中， F的值一般维持不变）；

3. 每颗树任其生长，不进行剪枝。

随机森林中有许多的分类树。我们要将一个输入样本进行分类，我们需要将输入样本输入到每棵树中进行分类。打个形象的比喻：森林中召开会议，讨论某个动物到底是老鼠还是松鼠，每棵树都要独立地发表自己对这个问题的看法，也就是每棵树都要投票。该动物到底是老鼠还是松鼠，要依据投票情况来确定，获得票数最多的类别就是森林的分类结果。

将若干个弱分类器的分类结果进行投票选择，从而组成一个强分类器，这就是随机森林bagging的思想·

关于bagging的一个有必要提及的问题：bagging的代价是不用单棵决策树来做预测，具体哪个变量起到重要作用变得未知，所以bagging改进了预测准确率但损失了解释性。

影响随机森林分类性能的主要因素：

• 森林中单颗树的分类强度（Strength）：每颗树的分类强度越大，则随机森林的分类性能越好。

• 森林中树之间的相关度（Correlation）：树之间的相关度越大，则随机森林的分类性能越差。

随机森林优缺点：

• 在当前所有算法中，具有极好的准确率；

• 训练可以高度并行化，能够有效地运行在大数据集上；

• 能够处理具有高维特征的输入样本，而且不需要降维；

• 对部分特征缺失不敏感。

•可解释性差

•容易发生过拟合

"""
--RandomForest调参示例--
"""
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn import cross_validation, metrics
from sklearn.model_selection import GridSearchCV, train_test_split

import matplotlib.pylab as plt

train_path = 'car.csv'

# 读取数据文件
data_frame_train = pd.read_csv(train_path, encoding='gbk')

# 划分训练集和测试集的X，y
X, y = data_frame_train.values[:, :-1], data_frame_train.values[:, -1]
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3)

# 不调整参数的效果(oob_score=True:采用袋外样本来评估模型的好坏,反映了模型的泛化能力)
def default_param():
    # 实例化模型
    rfclf = RandomForestClassifier(oob_score=True, random_state=10)
    # 模型训练
    rfclf.fit(X_train, y_train)
    # 模型对测试集进行预测
    y_pre = rfclf.predict(X_test)   # 预测值
    y_prb_1 = rfclf.predict_proba(X_test)[:, 1]  # 预测为1的概率
    # 输出oob_score以及auc
    print(rfclf.oob_score_)  # 0.8407142857142857
    print(rfclf.score(X_test,y_test))
    print("AUC Score: %f" % metrics.roc_auc_score(y_test, y_prb_1))


# 调节RandomForest最大决策树个数
def adjust_n_estimators():
    param_test1 = {'n_estimators': range(10, 71, 10),'max_depth': range(3, 14, 2)}
    gsearch1 = GridSearchCV(estimator=RandomForestClassifier(min_samples_split=100,
                                                             min_samples_leaf=20, max_depth=8, max_features='sqrt',
                                                             random_state=10),
                            param_grid=param_test1, scoring='roc_auc', cv=5)
    gsearch1.fit(X_train, y_train)
    print('best params:{0}'.format(gsearch1.best_params_))
    print('best score:{0}'.format(gsearch1.best_score_))
    # best params:{'n_estimators': 70}
    #best params:{'max_depth': 5, 'n_estimators': 50}


# 再调节决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split
def adjust_depth_samples():
    param_test2 = {'max_depth': range(3, 14, 2), 'min_samples_split': range(50, 201, 20)}
    gsearch2 = GridSearchCV(estimator=RandomForestClassifier(n_estimators=70,
                                                             min_samples_leaf=20, max_features='sqrt', oob_score=True,
                                                             random_state=10),
                            param_grid=param_test2, scoring='roc_auc', iid=False, cv=5)
    gsearch2.fit(X_train, y_train)
    print('best params:{0}'.format(gsearch2.best_params_))
    print('best score:{0}'.format(gsearch2.best_score_))
    # best params:{'max_depth': 5, 'min_samples_split': 70}
    # best params:{'max_depth': 7, 'min_samples_split': 50}


# 目前模型下的袋外分数(是否提高--泛化能力)
def current_oob_score():
    rf1 = RandomForestClassifier(n_estimators= 70, max_depth=5, min_samples_split=70,
                                      min_samples_leaf=20,max_features='sqrt' ,oob_score=True, random_state=10)
    rf1.fit(X_train,y_train)
    print(rf1.oob_score_)   # 0.8635714285714285


# min_samples_split和决策树其他的参数存在关联,需要内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf一起调参。
def adjust_samples_leaf():
    param_test3 = {'min_samples_split': range(50, 150, 20), 'min_samples_leaf': range(10, 60, 10)}
    gsearch3 = GridSearchCV(estimator=RandomForestClassifier(n_estimators=70, max_depth=5,
                                                             max_features='sqrt', oob_score=True, random_state=10),
                            param_grid=param_test3, scoring='roc_auc', iid=False, cv=5)
    gsearch3.fit(X_train, y_train)
    print('best params:{0}'.format(gsearch3.best_params_))
    print('best score:{0}'.format(gsearch3.best_score_))
    # best params:{'min_samples_leaf': 10, 'min_samples_split': 80}
    #best params:{'min_samples_leaf': 10, 'min_samples_split': 50} 0.9346826586706646


# 对最大特征数进行调参
def adjust_max_features():
    param_test4 = {'max_features': range(2, 11,2)}
    gsearch4 = GridSearchCV(estimator=RandomForestClassifier(n_estimators=70, max_depth=5, min_samples_split=80,
                                                             min_samples_leaf=10, oob_score=True, random_state=10),
                            param_grid=param_test4, scoring='roc_auc', iid=False, cv=5)
    gsearch4.fit(X_train, y_train)
    print('best params:{0}'.format(gsearch4.best_params_))
    print('best score:{0}'.format(gsearch4.best_score_))
    # best params:{'max_features': 3} {'max_features': 10}


# 最终模型的效果(泛化能力依旧不足？-->找更多数据！)
def best_params():
    rf2 = RandomForestClassifier(n_estimators=50, max_depth=5, min_samples_split=50,
                                 min_samples_leaf=10,max_features=10,oob_score=True, random_state=10)
    rf2.fit(X_train, y_train)
    print(rf2.oob_score_)  # 0.8571428571428571
    print(rf2.score(X_test,y_test))

if __name__ == '__main__':
    pass
    # default_param()
    # adjust_n_estimators()
    # adjust_depth_samples()
    # current_oob_score()
    # adjust_samples_leaf()
    # adjust_max_features()
    best_params()

AdaBoost

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from sklearn.model_selection import GridSearchCV
import numpy as np
import matplotlib.pyplot as plt

df = pd.read_csv("car.csv",encoding="gbk")
x_train,x_test,y_train,y_test = train_test_split(df.values[:,:-1],df.values[:,-1],test_size=0.3,random_state=10)

def get_n_estimators():
    estimators = range(10,100)
    score = []
    for n_estimators in estimators:
        model = AdaBoostClassifier(n_estimators=n_estimators)
        model.fit(x_train,y_train)
        score.append(model.score(x_test,y_test))
    print(np.max(score))
    plt.plot(estimators,score)
    plt.show()
def get_learing_rate():
    learning_rate =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]
    score = []
    for i in learning_rate :
        model = AdaBoostClassifier(learning_rate =i)
        model.fit(x_train, y_train)
        score.append(model.score(x_test, y_test))
    print(np.max(score))
    plt.plot(learning_rate , score)
    plt.show()
def best():
    model = AdaBoostClassifier(n_estimators=70,learning_rate=0.3)
    model.fit(x_train, y_train)
    print(model.score(x_test,y_test))
if __name__=="__main__":
    # get_n_estimators()
    get_learing_rate()
    # best()

GBDT

决策树：是将空间用超平面进行划分的一种方法

分类树

回归树

单决策树时间复杂度较低，模型容易展示，但容易overfitting

决策树的boost方法：是一个迭代的过程，每一次新的训练都是为了改进上一次的结果.

传统Boost：对正确、错误的样本进行加权，每一步结束后，增加分错的点的权重，减少分对的点的权重。

GBDT：每一次建立模型是在之前建立的模型损失函数的梯度下降方向。

GBDT(Gradient Boosting Decision Tree) ：是一种迭代的决策树算法，该算法由多棵决策树组成，所有树的结论累加起来做最终结果。
GBDT这个算法还有一些其他的名字，MART(Multiple Additive Regression Tree)，GBRT(Gradient Boost Regression Tree)，TreeNet，Treelink等。

GBDT算法原理

提升树利用加法模型与前向分布算法实现学习的优化过程

前向分布算法

应用范围
   GBDT几乎可用于所有回归问题（线性/非线性）
   亦可用于二分类问题（设定阈值，大于阈值为正例，反之为负例）；不太适合做多分类问题；
   排序问题；
   常用于各大数据挖掘竞赛（模型融合）；
   广告推荐

   CTR预估：广告点击率（Click-Through RatePrediction）
   CTR预估中用的最多的模型是LR（LogisticRegression），LR是广义线性模型，与传统线性模型相比，LR使用了Logit变换将函数值映射到0~1区间 ，映射后的函数值就是CTR的预估值。
   LR，逻辑回归模型，这种线性模型很容易并行化，处理上亿条训练样本不是问题，但线性模型学习能力有限，需要大量特征工程预先分析出有效的特征、特征组合，从而去间接增强LR 的非线性学习能力

   LR模型中的特征组合很关键，但又无法直接通过特征笛卡尔积解决，只能依靠人工经验，耗时耗力同时并不一定会带来效果提升。如何自动发现有效的特征、特征组合，弥补人工经验不足，缩短LR特征实验周期，是亟需解决的问题
   Facebook 2014年的文章介绍了通过GBDT（Gradient Boost Decision Tree）解决LR的特征组合问题，随后Kaggle竞赛也有实践此思路GDBT+FM，GBDT与LR融合开始引起了业界关注

"""
--GBDT调参示例--
"""
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn import cross_validation, metrics
from sklearn.model_selection import GridSearchCV, train_test_split

import matplotlib.pylab as plt

train_path = 'data.csv'

# 读取数据文件
data_frame_train = pd.read_csv(train_path, encoding='gbk')

# 划分训练集和测试集的X，y
X_train, y_train = data_frame_train.values[:, :-1], data_frame_train.values[:, -1]


# 不调整参数的效果
def default_param():
    # 实例化模型
    gbclf = GradientBoostingClassifier(random_state=10)
    # 模型训练
    gbclf.fit(X_train, y_train)
    # 模型对测试集进行预测
    y_pre = gbclf.predict(X_train)   # 预测值
    y_prb_1 = gbclf.predict_proba(X_train)[:, 1]  # 预测为1的概率
    # 输出预测准确度
    print("Accuracy : %.4g" % metrics.accuracy_score(y_train, y_pre))
    print("AUC Score: %f" % metrics.roc_auc_score(y_train, y_prb_1))


# 首先从步长(learning rate)和迭代次数(n_estimators)入手，将步长初始值设置为0.1，对迭代次数进行网格搜索。
def adjust_n_estimators():
    param_dic = {'n_estimators': range(10, 101, 10),"max_depth":range(3,10)}
    gscv = GridSearchCV(estimator=GradientBoostingClassifier(learning_rate=0.1, min_samples_split=300,
                                                                 min_samples_leaf=20, max_depth=8, max_features='sqrt',
                                                                 subsample=0.8, random_state=10),
                            param_grid=param_dic, scoring='roc_auc', iid=False, cv=5)
    gscv.fit(X_train, y_train)

    # print('result:{0}'.format(gscv.cv_results_))
    # result_df = pd.DataFrame(gscv.cv_results_)
    # result_df.to_csv('C:/Users/Lenovo/Desktop/result.csv', index=False)
    print('best_params:{0}'.format(gscv.best_params_))
    print('best_score:{0}'.format(gscv.best_score_))
    # best_n_estimators = 10


# 迭代次数有了，接下来对决策树进行调参：
# 首先对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网格搜索
def adjust_depth_samples():
    param_dic = {'max_depth': range(3, 14, 2), 'min_samples_split': range(100, 801, 200)}
    # 迭代次数选10
    gscv = GridSearchCV(estimator=GradientBoostingClassifier(learning_rate=0.1, n_estimators=10, min_samples_leaf=20,
                                             max_features='sqrt', subsample=0.8, random_state=10),
                                             param_grid=param_dic, scoring='roc_auc', iid=False, cv=5)
    gscv.fit(X_train, y_train)
    print('best_params:{0}'.format(gscv.best_params_))
    print('best_score:{0}'.format(gscv.best_score_))
    # max_depth: 3, min_samples_split: 100


# 先定下深度为3，但min_samples_split和其它参数还有关联，接下来要和min_samples_leaf一起调参
def adjust_samples_leaf():
    param_dic = {'min_samples_split':range(800,1900,200), 'min_samples_leaf':range(40,101,10)}
    gscv = GridSearchCV(estimator=GradientBoostingClassifier(learning_rate=0.1, n_estimators=10,max_depth=3,
                                         max_features='sqrt', subsample=0.8, random_state=10),
                                         param_grid = param_dic, scoring='roc_auc',iid=False, cv=5)
    gscv.fit(X_train,y_train)
    print('best_params:{0}'.format(gscv.best_params_))
    print('best_score:{0}'.format(gscv.best_score_))
    # min_samples_leaf: 90, min_samples_split: 800


# 用选出来的参数去训练数据
def best_param():
    # 实例化模型
    gbclf = GradientBoostingClassifier(learning_rate=0.1, n_estimators=10, max_depth=8,min_samples_leaf=90,
                                       min_samples_split=800, max_features='sqrt', subsample=0.8, random_state=10)
    # 模型训练
    gbclf.fit(X_train, y_train)
    # 模型对测试集进行预测
    y_pre = gbclf.predict(X_train)   # 预测值
    y_prb_1 = gbclf.predict_proba(X_train)[:, 1]  # 预测为1的概率
    # 输出预测准确度
    print("Accuracy : %.4g" % metrics.accuracy_score(y_train, y_pre))
    print("AUC Score: %f" % metrics.roc_auc_score(y_train, y_prb_1))

# todo:在现有参数基础上接着调整max_features, subsample, learning_rate
if __name__ == '__main__':
    pass
    # default_param()     # 0.9285
    # adjust_n_estimators() # 10
    # adjust_depth_samples() # 3 100
    # adjust_samples_leaf()
    #best_param()

gbdt+lr

from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import roc_curve
# 弱分类器的数目
n_estimator = 10
# 随机生成分类数据。
X, y = make_classification(n_samples=8000)
# 切分为测试集和训练集，比例0.5
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)
# 将训练集切分为两部分，一部分用于训练GBDT模型，另一部分输入到训练好的GBDT模型生成GBDT特征，然后作为LR的特征。这样分成两部分是为了防止过拟合。
X_train, X_train_lr, y_train, y_train_lr = train_test_split(X_train, y_train, test_size=0.5)
# 调用GBDT分类模型。
grd = GradientBoostingClassifier(n_estimators=n_estimator)
# 调用one-hot编码。
grd_enc = OneHotEncoder()
# 调用LR分类模型。
grd_lm = LogisticRegression()


'''使用X_train训练GBDT模型，后面用此模型构造特征'''
grd.fit(X_train, y_train)

# fit one-hot编码器
grd_enc.fit(grd.apply(X_train)[:, :, 0])
#print(grd.apply(X_train)[:, :, 0])
''' 
使用训练好的GBDT模型构建特征，然后将特征经过one-hot编码作为新的特征输入到LR模型训练。
'''
grd_lm.fit(grd_enc.transform(grd.apply(X_train_lr)[:, :, 0]), y_train_lr)
# 用训练好的LR模型多X_test做预测
y_pred_grd_lm = grd_lm.predict_proba(grd_enc.transform(grd.apply(X_test)[:, :, 0]))[:, 1]
# 根据预测结果输出
fpr_grd_lm, tpr_grd_lm, _ = roc_curve(y_test, y_pred_grd_lm)
import numpy as np
print( np.sum(grd_lm.predict(grd_enc.transform(grd.apply(X_test)[:, :, 0]))==y_test))
lr = LogisticRegression()
lr.fit(X_train_lr,y_train_lr)
print(np.sum(lr.predict(X_test)==y_test))

XGBoost

XGBoost本质上还是GBDT，但是把速度和效率做到了极致；
• 不 同 于 传 统 的GBDT方 式 ， 只 利 用 了一 阶 的 导 数 信 息，XGBoost对loss func做了二阶的泰勒展开，并在目标函数之外加入了正则项整体求最优解，用以权衡目标函数的下降和模型的复杂程度，避免过拟合

传统GBDT以CART作为基分类器，xgboost还支持线性分类器，这个时候xgboost相当于带L1和L2正则化项的逻辑回归（分类问题）或者线性回归（回归问题）。
• 传统GBDT在优化时只用到一阶导数信息，xgboost则对代价函数进行了二阶泰勒展开，同时用到了一阶和二阶导数。
• xgboost在代价函数里加入了正则项，用于控制模型的复杂度。正则项里包含了树的叶子节点个数、每个叶子节点上输出的score的L2模的平方和。正则项降低了模型的复杂度，使学习出来的模型更加简单，防止过拟合，这也是xgboost优于传统GBDT的一个特性。
• Shrinkage（缩减），相当于学习速率（xgboost中的eta）。xgboost在进行完一次迭代后，会将叶子节点的权重乘上该系数，主要是为了削弱每棵树的影响，让后面有更大的学习空间。实际应用中，一般把eta设置得小一点，然后迭代次数设置得大一点。
• 列抽样（column subsampling）。xgboost借鉴了随机森林的做法，支持列抽样，不仅能降低过拟合，还能减少计算，这也是xgboost异于传统gbdt的一个特性

• 可并行

import xgboost as xgb
import pandas as pd
from sklearn.model_selection import train_test_split
df = pd.read_csv("car.csv",encoding="gbk")
x_train,x_test,y_train,y_test = train_test_split(df.values[:,:-1],df.values[:,-1],test_size=0.3,random_state=10)

def default():
    dtrain = xgb.DMatrix(data=x_train,label=y_train)
    dtest = xgb.DMatrix(data=x_test,label=y_test)
    param = {'max_depth': 2, 'eta': 1, 'silent': 1, 'objective': 'binary:logistic'}
    model = xgb.train(param,dtrain)
    preds = model.predict(dtest)
    print(preds)
    l = [1 if i > 0.5 else 0 for i in preds]
    import numpy as np
    print(np.sum(l==y_test))
def example():
    dtrain = xgb.DMatrix('agaricus.txt.train')
    dtest = xgb.DMatrix('agaricus.txt.test')
    print(dtrain)
    param = {'max_depth':2, 'eta':1, 'silent':1, 'objective':'binary:logistic' }
    num_round = 2
    bst = xgb.train(param, dtrain, num_round)
    # make prediction
    preds = bst.predict(dtest)
    print(preds)

if __name__=="__main__":
    default()