集成学习 Ensemble Learing(？？？)

集成学习 Ensemble Learing

之前学习的决策树之类的学习方法都是单一的，独立的。
整体表现比较差的学习器，在一些样本上的表现是否有可能会超过“最好”的学习器。

bagging

举个栗子：
从十个数之中有放回的抽取十个数字，组成不同的几个数据集。


第二张图是集成学习的学习曲线。

from sklearn import neighbors
from sklearn import datasets
from sklearn.ensemble import BaggingClassifier
from sklearn import tree
from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

iris = datasets.load_iris()
x_data = iris.data[:,:2]
y_data = iris.target

x_train,x_test,y_train,y_test = train_test_split(x_data,y_data)

#建立knn的模型
knn = neighbors.KNeighborsClassifier()
knn.fit(x_train,y_train)

def plot(model):
    x_min,x_max = x_data[:,0].min() - 1,x_data[:,0].max() + 1
    y_min,y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    # 生成网格矩阵
    xx,yy = np.meshgrid(np.arange(x_min,x_max,0.02),
                        np.arange(y_min,y_max,0.02))
    z = model.predict(np.c_[xx.ravel(),yy.ravel()])
    z = z.reshape(xx.shape)
    #等高线图
    cs = plt.contourf(xx,yy,z)

plot(knn)
#样本散点图
plt.scatter(x_data[:,0],x_data[:,1],c=y_data)
plt.show()
#准确率
print(knn.score(x_test,y_test))

#画决策树(决策树特别容易出现过拟合，所以准确率有点低)
dtree = tree.DecisionTreeClassifier()
dtree.fit(x_train,y_train)
plot(dtree)
plt.scatter(x_data[:,0],x_data[:,1],c=y_data)
plt.show()
print(dtree.score(x_test,y_test))

#集成学习模型
#n_estimators=100有放回的抽样进行100次，则会建立100次knn的模型
bagging_knn = BaggingClassifier(knn,n_estimators=100)

bagging_knn.fit(x_train,y_train)
plot(bagging_knn)

plt.scatter(x_data[:,0],x_data[:,1],c=y_data)
plt.show()

print(bagging_knn.score(x_test,y_test))

我运行后得到的答案总是knn和knn集成相同，有、、疑惑，难道现在knn训练已经准确到无论分成多少次最后都一样了吗？感觉不应该啊！还出现了集成学习比直接学习正确率更低的情况，还有knn和决策树的学习正确率在同一次运行时出现了同一种效果也比较疑惑。并且我发现在运行多次后，knn或决策树或时两种集成学习，它们会出现同样的正确率。似乎就是那么几个数字在来回变换。在同一次练习之中，他们会不会出现互相影响的情况呢？

随机森林Random Forest

RF = 决策树 + Bagging + 随机属性选择

RF算法流程
散点图：
决策树等高线图：

随机森林等高线图：

多次运行时决策树和随机森林的正确率：




代码如下：

from sklearn.ensemble import RandomForestClassifier
from sklearn import tree
from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

data = np.genfromtxt("LR-testSet2.txt",delimiter=',')
x_data = data[:,:-1]
y_data = data[:,-1]
plt.scatter(x_data[:,0],x_data[:,1],c=y_data)
plt.show()

x_train,x_test,y_train,y_test =train_test_split(x_data,y_data,test_size=0.5)

def plot(model):
    x_min,x_max = x_data[:,0].min() - 1,x_data[:,0].max() + 1
    y_min,y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    # 生成网格矩阵
    xx,yy = np.meshgrid(np.arange(x_min,x_max,0.02),
                        np.arange(y_min,y_max,0.02))
    z = model.predict(np.c_[xx.ravel(),yy.ravel()])
    z = z.reshape(xx.shape)
    #等高线图
    cs = plt.contourf(xx,yy,z)
    plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    plt.show()
dtree = tree.DecisionTreeClassifier()
dtree.fit(x_train,y_train)
plot(dtree)
print(dtree.score(x_test,y_test))

RF = RandomForestClassifier(n_estimators=50)
RF.fit(x_train,y_train)
plot(RF)
print(RF.score(x_test,y_test))

Boosting

AdaBoost是英文“Adaptive Boosting”（自适应增强）的缩写，它的自适应在于：前一个基本分类器被错误分类的样本的权值会增大，而正确分类的样本的权值会减小，并再次用来训练下一个基本分类器。同时，在每一轮迭代中，加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数才确定最终的强分类器。

直觉：将学习器的重点放在“容易”出错的样
本上。可以提升学习器的性能。

Adaboost算法可以简述为三个步骤：
（1）首先，是初始化训练数据的权值分布D1。假设有N个训练样本数据，则每一个训练样本最开始时，都被赋予相同的权值：w1=1/N。
（2）然后，训练弱分类器hi。具体训练过程中是：如果某个训练样本点，被弱分类器hi准确地分类，那么在构造下一个训练集中，它对应的权值要减小；相反，如果某个训练样本点被错误分类，那么它的权值就应该增大。权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去。
（3）最后，将各个训练得到的弱分类器组合成一个强分类器。各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决定作用。换而言之，误差率低的弱分类器在最终分类器中占的权重较大，否则较小。

Adaboost

训练过程：
判断过程：
算法流程：

所得结果：



这种集成学习的效果要好的多。

Stacking 和 Voting介绍和使用

使用多个不同的分类器对训练集进预测，把预测得到的结果作为一个次级分类器的输入。次级分类器的输出是整个模型的预测结果。


Stacking：

from sklearn import datasets
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from mlxtend.classifier import StackingClassifier
import numpy as np

import warnings
warnings.filterwarnings("ignore")

iris = datasets.load_iris()
#只要第1、2列的特征，iris数据集一行有四个数据，每一个数据标签如下，target是分类的结果
#['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
x_data,y_data = iris.data[:,1:3],iris.target

#定义三个不同的分类器
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = DecisionTreeClassifier()
clf3 = LogisticRegression()

#定义一个次分类器
lr = LogisticRegression()
sclf = StackingClassifier(classifiers=[clf1,clf2,clf3],
                          meta_classifier=lr)
for clf,label in zip([clf1,clf2,clf3,sclf],
                     ['KNN','Decision Tree','LogisticRegression','StackingClassifier']) :
    scores = model_selection.cross_val_score(clf,x_data,y_data,cv=3,scoring='accuracy')
    print("Accuracy:%0.2f[%s]"%(scores.mean(),label))

总结：

Kaggle

网址：https://www.kaggle.com/

举个栗子：泰坦尼克号船员获救预测项目

数据：（可以到kaggle官网下载）