机器学习之分类算法

如果目标值为 类别， 则属于分类问题，使用分类算法

1、sklearn转换器和预估器（估计器）

转换器 —特征工程的父类

1）实例化（实例化的是一个转换器类（Transformer））

2）调用fit_transform（对于文档建立分类词频矩阵，不能同时调用）

fit_transform(X) 方法是由 fit() 方法和 transform() 方法封装而成

比如，在标准化的时候，标准化的公式：x’ = (x - mean) / std

fit()方法干的事情就是计算传进去的数据中每一列的标准差和平均值

transform()方法干的事情是将标准差和平均值代入公式( x-mean ) / std，进行最终的转换

关于fit()、transform()、fit_transform()，想要了解更多，可以看一下源码实现！

预估器（estimator）

在sklearn中，所有机器学习的一些算法都被封装到估计器这个父类当中，是一类实现了算法的API

1）实例化一个estimator

2）estimator.fit(x_train, y_train) 将训练集的特征值和目标值传进去、进行计算，相当于在做机器学习的训练，当fit()方法调用完，意味着这个 模型 已经 生成 了（训练完毕）。

3）模型评估

方法一：直接比对真实值和预测值

y_predict = estimator.predict(x_test) 把测试集的特征值数据传进去生成相应的目标值预测结果

print(‘直接比对真实值和预测值：\n’, y_test == y_ test_ predict ) —打印True或False的ndarray数组

if np.array_equal(y_test_predict, y_test):

print(“模型预测完全成功”)

方法二：计算准确率

accuracy = estimator.score(x_test, y_test) 将测试集的特征值和目标值传进去计算出accuracy（准确率）

用于分类的估计器

sklearn.neighbors k-近邻算法

sklearn.naive_bayes 贝叶斯

sklearn.linear_model.LogisticRegression 逻辑回归

sklearn.tree 决策树与随机森林

用于回归的估计器

sklearn.linear_model.LinearRegression 线性回归

sklearn.linear_model.Ridge 岭回归

3）用于无监督学习的估计器

sklearn.cluster.KMeans 聚类

2、第一个算法— KNN算法 （也叫K-近邻算法）（属于分类算法）

“通过你的邻居判断你的类别”

K—K的取值是一个自然数 N—nearest 最近的 N—neighbor 邻居，机器学习中的一个经典算法

KNN算法最早是在1968年由Cover和Hart提出的一种分类算法

核心思想：根据你的“邻居”来推断你的类别

定义：如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。

假如我在红色圈圈那个地方，但是我不知道我所在哪个区域（这是一个分类问题），只知道五个人到我的距离和他们所在的区域，那么离我最近的那个人所在的区域很可能就是我所在的区域，这就是KNN算法的思路。

在判断我所在的位置的时候，只选择了一个离我最近的那个人，即K=1，容易受到异常值的影响。K取一个合适的数值，可以有效避免异常值。

如何确定谁是邻居？

计算距离

计算距离的方法：欧氏距离、曼哈顿距离、明可夫斯基距离（是欧氏距离和曼哈顿距离的一个推广），最常用的是欧氏距离。

比如：有两个样本a和b

a的特征值为(a1, a2, a3)，b的特征值为(b1, b2, b3)

那么这两个样本之间的欧氏距离为：

那么这两个样本之间的 曼哈顿距离为：

|a1 - b1| + |a2 - b2| + |a3 - b3|

示例：利用KNN算法来进行电影类型分析（预测？电影是什么类型）

当k=1时，？电影离He’s not…电影最近，预测为爱情片

当k=2时，？电影离He’s not…和Beautiful…电影最近，预测为爱情片

——

当k=6时，离 ？电影最近的 6个电影当中， 3个为爱情片，3个为动作片， 无法确定类型

如果在电影列表当中新增一部类型为动作片的电影，当k=7时， 离？电影最近的7个电影当中，3个为爱情片，4个为动作片，导致被错分为动作片。

KNN算法存在的问题：

k值取得过小，容易受到异常值的影响

k值取得过大，容易受到样本不均衡的影响

如何在sklearn中使用KNN算法？

API：sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, algorithm=‘auto’)

Classfier—分类器

n_neighbors：int，可选（默认为5），即K值，一般取奇数

algorithm：{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}，按默认auto即可

当我们调用这个API时，默认使用的距离计算方法为欧氏距离，我们进入这个API，p=2默认使用欧氏距离来进行KNN计算寻找最近距离。

示例：鸢尾花种类预测

总体思路：

1）获取数据

2）数据集划分

3）特征工程

标准化

4）KNN预估器流程

5）模型评估

代码：

from sklearn.datasets import load_iris 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import StandardScaler 
from sklearn.neighbors import KNeighborsClassifier 
def knn_iris(): 
    ''' 
    用KNN算法对鸢尾花进行分类 
    :return: 
    ''' 
    # 1.获取鸢尾花数据集 
    iris = load_iris() 
    # 2.数据集划分，test_size是划分测试集数据大小，random_state：选择不同的随机数种子，分到的样本不同，准确率也就不同 
    x_train, x_test,  y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=22) 
    # 3.进行特征工程：标准化 
    transfer = StandardScaler() 
    # 调用fit_transform()，fit_transform()封装了fit()和transform() 
    # fit()用于计算，相当于对训练集每个特征求了一个平均值和标准差（见标准化公式），然后进行transform()标准化 
    x_train_new = transfer.fit_transform(x_train) 
    # 用tranform()对测试集做标准化 
    # 如果调用fit_transform()相当于又做了一次计算，求测试集的平均值和标准差 
    # 要求测试集和训练集做一样的处理，所以要用训练集特征中的平均值和标准差来对测试集的特征数据做标准化 
    x_test_new = transfer.transform(x_test) 
    # 4.实例化一个KNN算法预估器，K值不同，准确率也就可能不同 
    estimator = KNeighborsClassifier(n_neighbors=3) 
    # 对预估器进行模型训练 
    estimator.fit(x_train_new, y_train) 
    # 5.模型评估 
    # 方法一：直接比对真实值和预测值 
    # 传入测试数据的特征值，得到预测的目标值 
    y_test_predict = estimator.predict(x_test_new) 
    print('预测的目标值：\n', y_test_predict) 
    print('真实的目标值：\n', y_test) 
    print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
    # 方法二：计算准确率 
    score = estimator.score(x_test_new, y_test) 
    print('准确率为：\n', score) 
    return None 

if __name__ == '__main__': 
    # 用KNN算法对鸢尾花进行分类 
    knn_iris() 

结果：

KNN算法总结：

优点：简单，易于理解，易于实现，无需训练

缺点：懒惰算法，对测试样本分类时的计算量大，内存开销大

必须指定K值，K值选择不当则分类精度不能保证

使用场景：小数据场景，几千~几万样本，具体场景具体业务去测试

3、模型选择与调优

交差验证（cross validation,简称CV）

定义：将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成4份，其中一份作为验证集。然后经过四次（组）的 测试，每次都更换不同的验证集。即得到4组模型的结果，取平均值作为最终结果。又称4折交叉验证。

训练集：训练集+验证集

测试集：测试集

交叉验证的目的：为了让从训练得到模型结果更加准确

超参数搜索—网格搜索（Grid Search）

目的：对K值进行选择，选择最合适的K值

定义：通常情况下，有很多参数时需要手动指定的（如k-近邻算法中的K值），这种叫 超参数 。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。

API：sklearn.model_selection.GridSearchCV(estimator, param_grid=None, cv=None, n_jobs=1)

GridSearchCV——网格搜索和交叉验证

estimator：估计器对象，比如对KNN算法加上网格搜索交叉验证功能，就把实例化后的KNN算法预估器传进来

param_grid：将想要试的超参数以 字典 的形式传进来，比如K的取值为[1, 3, 5]，则param_grid = {“n_neighbors”:[1, 3, 5]}

cv：指定几折交叉验证，即如果要校验哪个K值好，那么每检验一个K值要进行几次交叉验证，使得出来的结果更准确，一般设置十折交叉验证。

n_jobs：代表为用几个CPU来跑这个模型，默认为1，如果为-1代表CPU满负荷运行，（不建议设为-1，伤电脑）

返回值：sklearn.model_selection._search.GridSearchCV

这个API的返回值也相当于是继承自预估器的一个类，所以使用时和预估器的使用是一样的

GridSearchCV.fit()：输入训练数据

GridSearchCV.score()：计算准确率

GridSearchCV.fit()训练之后，可以查看结果分析：

GridSearchCV类中包含的字段（field），直接调用，不需要括号

最佳参数：best_params_

最佳结果：best_score_

最佳估计器：best_estimator_

交叉验证结果：cv_results_

示例1：给上述 鸢尾花种类预测案例 增加K值调优

from sklearn.datasets import load_iris 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import StandardScaler 
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import GridSearchCV 

def knn_iris_gscv(): 
    ''' 
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证 
    :return: 
    ''' 
    # 1.获取鸢尾花数据集 
    iris = load_iris() 
    # 2.数据集划分 
    x_train, x_test,  y_train, y_test = train_test_split(iris.data, iris.target, random_state=22) 
    # 3.进行特征工程：标准化 
    transfer = StandardScaler() 
    x_train_new = transfer.fit_transform(x_train) 
    x_test_new = transfer.transform(x_test) 
    # 4.实例化一个KNN算法预估器，没有传入K值(即n_neighbors这个参数) 
    estimator = KNeighborsClassifier() 
    # 加入网格搜索和交叉验证， 用于选择最合适的K值，使得训练所得的模型用来测试时，准确率更高 
    # 参数准备，手动设置一个多K值列表的字典 
    param_dict = {'n_neighbors':[1, 3, 5, 7, 9, 11]} 
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10) 
    estimator.fit(x_train_new, y_train) 
    # 5.模型评估 
    # 方法一：直接比对真实值和预测值 
    y_test_predict = estimator.predict(x_test_new) 
    print('预测的目标值：\n', y_test_predict) 
    print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
    # 方法二：计算准确率，求得是测试集在训练集中的结果 
    score = estimator.score(x_test_new, y_test) 
    print('准确率为：\n', score) 
    # 最佳参数：best_params_ 
    print("最佳参数：\n", estimator.best_params_) 
    # 最佳结果：best_score_，交叉验证是对训练集进行划分 
    # 一部分用于训练，一部分用于验证，最佳结果求得是训练部分在验证部分的结果 
    print("最佳结果：\n", estimator.best_score_) 
    # 最佳估计器：best_estimator_ 
    print("最佳估计器：\n", estimator.best_estimator_) 
    return None 
     
if __name__ == '__main__': 
    knn_iris_gscv() 

结果：

示例2：预测facebook签到位置（Kaggle上的一个比赛）

先略，晚点补上！！！

4、第二个算法— 朴素贝叶斯算法 （属于分类算法）

概率基础

案例：已知小明时产品经理，体重超重，是否会被女神喜欢？ 二分类问题

1、P(喜欢) = 4/7

2、P(程序员，匀称) = 1/7 联合概率

3、P(程序员|喜欢) = 2/4 = 1/2 条件概率

4、P(程序员，超重|喜欢)= 1/4 既符合联合概率，也符合条件概率

利用贝叶斯公式来计算小明被喜欢的概率：

P(喜欢|产品经理，超重) =

分子：P(产品经理，超重|喜欢) * P(喜欢)

分母：P(产品经理，超重) = ？，按正常逻辑来说，这里的分母为0，因为不存在既是产品经理，体重又超重的样本，但是利用朴素贝叶斯算法，为什么称朴素？因为朴素贝叶斯算法假设特征与特征之间是相互独立的，即P(产品经理，超重) = P(产品经理) * P(超重)，因此可以计算出小明被女神喜欢的概率。

小明被女神喜欢的概率为 7/12

联合概率、条件概率与相互独立

联合概率：包含多个条件，且所有条件同时成立的概率

记作：P(A, B)

条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率

记作：P(A|B)

相互独立：如果P(A, B) = P(A)P(B)，则称事件A与事件相互独立

朴素贝叶斯公式：

（注：W为给定文档的特征值(频数统计，预测文档提供)，C为文档类别）

朴素贝叶斯，之所以朴素，就在于假设了特征与特征之间是相互独立的

朴素贝叶斯算法原理：

朴素+贝叶斯

应用场景：

文本分类

朴素贝叶斯应用在文本分类中的公式为：

其中C为不同文本类别

公式分为三个部分：

P©：每个文档类别的概率（某文档类别数/总文档数量）

P(W|C)：给定文本类别下特征（被预测文档中出现的词）的概率

计算方法：P(F1|C) = Ni / N

Ni为该F1词在C类别所有文档中出现的次数

N为所属类别C下的文档所有词出现的次数和

P(F1, F2, …)：预测文档中每个词的概率

示例：预测测试集属于哪个文本分类

利用朴素贝叶斯 在文本分类中的 公式来计算：

P(China类 | Chinese, Chinese, Chinese, Tokyo, Japan) =

分子： P(Chinese, Chinese, Chinese, Tokyo, Japan | China类) * P(China类)

= P(Chinese | China类)^3 * P(Tokyo| China类) * P(Japan | China类) * P(China类)

= 5/8^3 * 0 * 0 * 3/4 （没有引入拉普拉斯平滑系数）

= (5 + 1)/(8 + 6)^3 * (0 + 1) / (8 + 6) * (0 + 1) / (8 + 6) * 3/4 (引入拉普拉斯平滑系数，都需要引入)

≈ 0.06

注意P(Chinese | China类)的计算方法！！！

P(Chinese | China类) ≠ 1 而＝5/8，在China类里面出现了8个词，有5个词为Chinese。P(Tokyo | China类) = 0/8，样本量太少，在China类中没有出现Tokyo这个词，这样会导致整个结果为0，而要测试集的文本中出现了3次Chinese，结果极可能为China类，概率为0显然不符合我们的预期。

遇到概率值为0的情况怎么办？

引入 拉普拉斯平滑系数， ， 目的：防止计算出的分类概率为0。α为指定的系数一般为1，m为 训练文档中统计出的特征词个数（即训练集有多少种特征词，不是特征词出现的次数和） 。

分母： P(Chinese, Chinese, Chinese, Tokyo, Japan)

= P(Chinese) * P(Chinese) * P(Chinese) * P(Tokyo) * P(Japan)

分母和下面的非China类的分母相同，不需要求

P(非China类 | Chinese, Chinese, Chinese, Tokyo, Japan) =

分子：P(Chinese, Chinese, Chinese, Tokyo, Japan | 非China类) * P(非China类)

同上面分子的求法

分母：P(Chinese, Chinese, Chinese, Tokyo, Japan)

求出分子之后，比较一下，即可知道被测试的文本属于哪个文本分类

如何在Sklearn中使用朴素贝叶斯算法？

API：sklearn.naive_bayes.MultinomialNB(alpha=1.0)

naive：天真的（朴素） bayes：贝叶斯 MultinomialNB：朴素贝叶斯的一个方法

alpha：拉普拉斯平滑系数，默认为1.0

sklearn中的机器学习流程基本上都是一样的，即实例化一个预估器，然后调用fit()进行训练。

示例：20类新闻分类

1）获取数据，数据集为sklearn中自带的新闻数据集

2）划分数据集

3）特征工程：文本特征抽取

4）朴素贝叶斯预估器流程，训练好了之后有了模型

5）模型评估

代码：

from sklearn.datasets import fetch_20newsgroups 
from sklearn.feature_extraction.text import TfidfVectorizer 
from sklearn.naive_bayes import MultinomialNB 

def nb_news(): 
    ''' 
    用朴素贝叶斯算法对新闻进行分类 
    :return: 
    ''' 
    # 1）获取数据集 
    news = fetch_20newsgroups(data_home="D:\PythonWorkSpace\机器学习\scikit_learn_data", subset='all') 
    # 2）数据集划分 
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target) 
    # 3）特征工程：文本特征抽取—tf-idf 
    transfer = TfidfVectorizer() 
    x_train_new = transfer.fit_transform(x_train) 
    x_test_new = transfer.transform(x_test) 
    # 4）朴素贝叶斯算法预估器流程 
    estimator = MultinomialNB(alpha=1.0) 
    estimator.fit(x_train_new, y_train) 
    # 5）模型评估 
    # 方法一：直接比对真实值和预测值 
    y_test_predict = estimator.predict(x_test_new) 
    print('预测的目标值：\n', y_test_predict) 
    print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
    # 方法二：计算准确率，求得是测试集在训练集中的结果 
    score = estimator.score(x_test_new, y_test) 
    print('准确率为：\n', score) 
     
if __name__ == '__main__': 
    nb_news() 

结果：fetch_20newsgroups()，下载数据集

总结：

优点：发源于古典数学原理，有稳定的分类效率

对缺失数据不太敏感，常用于文本分类

分类准确率高，速度快

缺点：由于假定特征与特征之间相互独立，所以如果特征和特征之间有关联的话，效果就不会太好。

5、 决策树 （属于分类算法）

最早的决策树就是利用if-else结构分割数据的一种分类学习方法

理解：

如果是公务员还要看收入，如果收入高则看长相，如果长相好还要看年龄，如果年龄不合适（即使是公务员、收入高、长相好）直接就不见，因此，女孩最看重的是年龄。

决策树分类原理详解：

已知一个人的四个特征，预测是否贷款给这个人，根据什么条件来判断给不给某个人贷款更合适？

先看是否有房子，再看是否有工作，—看了 两个特征 ，可以决定是否贷款给这个人。

先看年龄，再看信贷情况，再看是否有工作—看了 三个特征， 不高效

如何找到一个数学方法让计算机自动地进行判断应该先看哪个特征后、看哪个特征，从而很快速的得出预测结果（即如何找到一个更高效的决策顺序）？

要使用到信息论的基础知识： 信息熵(shang) ， 信息增益

信息论中信息的定义：消除随机不定性的东西（称“香农定义”）

信息的衡量 — 信息熵（消除不定性的东西有多少，即得到的信息有多少）

信息熵的定义：H的专业术语，单位为比特

信息熵公式：

信息熵公式理解：总共有n个样本，要想计算n个样本的信息熵的话，就从第一个算到第n个，每一个样本都有一个可能性概率P(xi)，用概率乘以一个对数log b P(xi)，以b为底（b值可以自己定，一般取2为底）

假设现在来了一个人（年龄、工作、房子、信贷情况未知），即没有掌握这个人的信息

贷款情况：15个人里面有6个否，9个是。

求总的信息熵：H(总) = -(6/15 * log 2 (6/15) + 9/15 * log 2 (9/15)) ≈ 0.971 （结果即为总的不确定性）

当知道这个人的年龄（青年人），不确定性就会减少，如果能求出当知道某个特征之后不确定性减少的程度，再比较其他不确定性减少的程度，减少程度最多的就可以优先作为决策构建决策树。

信息增益的定义：特征A对训练数据集D的信息增益g(D,A)，定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差。即（已知某个特征，不确定性减少的程度，减少的程度最多的最先关注）——信息增益是决策树的划分依据之一。

信息增益公式：g(D,A) = H(D) - H(D|A)

信息增益公式理解：总的信息熵减去已知某个特征的条件下的信息熵，即为信息增益。

条件熵公式：

g(D,年龄) = H(D) - H(D | 年龄)

H(D | 青年) = -(2/5 * log 2 (2/5) + 3/5 * log 2 (3/5))

H(D | 中年) = -(2/5 * log 2 (2/5) + 3/5 * log 2 (3/5))

H(D | 老年) = -(1/5 * log 2 (2/5) + 4/5 * log 2 (4/5))

H(D | 年龄) = 1/3 H(青年) + 1/3 H(D | 中年) + 1/3 H(D | 老年)

所以g(D, 年龄) = 0.313

我们以A1、A2、A3、A4代表年龄、有工作、有自己的房子和贷款情况、最终计算的结果g(D | A1) = 0.313、g(D | A2) = 0.324、g(D | A3) = 0.420、g(D | A4)= 0.363，所以我们选择A3作为划分的第一个特征，这样我们 就可以一棵树慢慢建立。

如何在sklearn中使用？

决策树API：sklearn.tree.DecisionTreeClassifier(criterion=‘gini’, max_depth=None, random_state=None)

criterion：默认是"gini"系统，也可以选择信息增益的熵“entropy”

max_depth：树的深度大小

random_state：随机数种子

示例1：鸢尾花示例

from sklearn.datasets import load_iris 
from sklearn.model_selection import train_test_split 
from sklearn.tree import DecisionTreeClassifier 

def decision_iris(): 
    """ 
    用决策树对鸢尾花进行分类 
    :return: 
    """ 
    # 1）获取数据集 
    iris = load_iris() 
    # 2）数据集划分 
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22) 
    # 3）使用决策树预估器进行分类 
    estimator = DecisionTreeClassifier(criterion='entropy') 
    estimator.fit(x_train, y_train) 
    # 4）模型评估 
    # 方法一：直接比对真实值和预测值 
    y_test_predict = estimator.predict(x_test) 
    print('预测的目标值：\n', y_test_predict) 
    print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
    # 方法二：计算准确率，求得是测试集在训练集中的结果 
    score = estimator.score(x_test, y_test) 
    print('准确率为：\n', score) 
     
if __name__ == '__main__': 
    decision_iris() 

结果：

总结：比对之前的用KNN算法来判断鸢尾花种类的结果

发现准确率下降了3个百分点，因为KNN算法在小数据场景，准确率比较高

决策树可视化：

保存树的结构到dot文件：

API：sklearn.tree.export_graphviz(estimator, out_file=‘tree.dot’, feature_names=[’’, ‘’]) 该函数能导出DOT格式

estimator：传入预估器

out_file：导出树的文件名

feature_names：特征名

在上面的代码中，添加如下 代码即可：

from sklearn.tree import export_graphviz 
# 可视化决策树 
export_graphviz(estimator, out_file='iris_tree.dot') 

导出的是文本文件，如下：

digraph Tree { 
node [shape=box] ; 
0 [label="X[2] <= 2.45\nentropy = 1.584\nsamples = 112\nvalue = [39, 37, 36]"] ; 
1 [label="entropy = 0.0\nsamples = 39\nvalue = [39, 0, 0]"] ; 
0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ; 
2 [label="X[3] <= 1.75\nentropy = 1.0\nsamples = 73\nvalue = [0, 37, 36]"] ; 
0 -> 2 [labeldistance=2.5, labelangle=-45, headlabel="False"] ; 
3 [label="X[2] <= 5.05\nentropy = 0.391\nsamples = 39\nvalue = [0, 36, 3]"] ; 
2 -> 3 ; 
4 [label="X[3] <= 1.65\nentropy = 0.183\nsamples = 36\nvalue = [0, 35, 1]"] ; 
3 -> 4 ; 
5 [label="entropy = 0.0\nsamples = 34\nvalue = [0, 34, 0]"] ; 
4 -> 5 ; 
6 [label="X[2] <= 4.75\nentropy = 1.0\nsamples = 2\nvalue = [0, 1, 1]"] ; 
4 -> 6 ; 
7 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ; 
6 -> 7 ; 
8 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 
6 -> 8 ; 
9 [label="X[0] <= 6.05\nentropy = 0.918\nsamples = 3\nvalue = [0, 1, 2]"] ; 
3 -> 9 ; 
10 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 
9 -> 10 ; 
11 [label="entropy = 0.0\nsamples = 2\nvalue = [0, 0, 2]"] ; 
9 -> 11 ; 
12 [label="X[2] <= 4.85\nentropy = 0.191\nsamples = 34\nvalue = [0, 1, 33]"] ; 
2 -> 12 ; 
13 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 
12 -> 13 ; 
14 [label="entropy = 0.0\nsamples = 33\nvalue = [0, 0, 33]"] ; 
12 -> 14 ; 
} 

要想可视化看到树，打开下列网站： http://webgraphviz.com/（如果无法Generate Gragh请使用科学上网工具）

将上面导出的.dot文件内容复制到网站文本框，点击Generate Gragh即可生成可视化决策树，如下：

不明白X[2]，X[3]含义是什么，因为没有传入feature_names，设置feature_names参数即可

export_graphviz(estimator, out_file='iris_tree.dot', feature_names='iris.feature_names') 

决策树总结：

优点：可以可视化——可解释能力强

缺点：如果max_depth不设置，并且数据量的特征很多，那么树就会分常长，容易产生 过拟合

改进：减枝cart算法（决策树API当中已经实现，随机森林参数调优有相关介绍）

随机森林

示例2：泰坦尼克号乘客生存预测

数据： http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt

可直接下载附件：

titanic.csv

数据集中的特征名(feature_names)：

|row.names |pclass |name |age |embarked |home.dest |room |ticket |boat |sex |

|:----|:----|:----|:----|:----|:----|:----|:----|:----|:----|

数据集 中的目标：是否能存活下来（1代表存活，0代表死亡）

|survived |

|:----|

选取可能影响目标值的特征：pclass（1、2、3对应乘客所在值1、2、3对应乘客所在舱位————头等舱、二等舱、平民舱，社会经济阶层的代表社会经济阶层的代表），age（年龄，存在缺失值，有缺失值）、sex（性别）

流程分析：

1）获取数据

2）数据处理

缺失值处理

特征值 转换为 字典类型

3）划分数据集

4）特征工程：字典特征抽取

5）决策树预估器流程

6）模型评估

代码（Jupyter notebookj）：

import pandas as pd 
# 1、获取数据 
path = 'titanic.csv' 
titanic = pd.read_csv(path) 

# 筛选特征值和目标值 
x = titanic[['pclass', 'sex', 'age']] 
y = titanic['survived'] 

# 2、数据处理 
# 1）缺失值处理,缺失处填入平均值 
x['age'].fillna(x['age'].mean(), inplace=True) 

# 2）特征值转换为字典 
x = x.to_dict(orient='records') 

部分截图

from sklearn.model_selection import train_test_split 
# 3、数据集划分 
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22) 
# 4、特征工程：字典特征抽取 
from sklearn.feature_extraction import DictVectorizer 
transfer = DictVectorizer() 
x_train_new = transfer.fit_transform(x_train) 
x_test_new = transfer.transform(x_test) 

x_train_new为sparse矩阵，查看特征名，pclass有三个，sex有两个，age有一个

from sklearn.tree import DecisionTreeClassifier, export_graphviz 
# 5、使用决策树预估器 
estimator = DecisionTreeClassifier(criterion='entropy') 
estimator.fit(x_train_new, y_train) 
# 6、模型评估 
# 方法一：直接比对真实值和预测值 
y_test_predict = estimator.predict(x_test_new) 
print('预测的目标值：\n', y_test_predict) 
print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
# 方法二：计算准确率，求得是测试集在训练集中的结果 
score = estimator.score(x_test_new, y_test) 
print('准确率为：\n', score) 
# 可视化决策树 
export_graphviz(estimator, out_file='titanic_tree.dot', feature_names=transfer.get_feature_names()) 

结果：

将生成的titanic_tree.dot文件内容复制到 http://webgraphviz.com/，即可生成决策树

会发现决策树太冗余，那么可以通过设置max_depth来决定决策树的分枝数量。

estimator = DecisionTreeClassifier(criterion='entropy', max_depth=5) 

结果：

准确率提高了1个百分点，而且决策冗余也去掉了。

6、 随机森林 （属于分类算法）——集成学习方法之一

随机：

两个随机：

训练集随机—N个样本中随机有放回的抽样N个

采用bootstrap方法——随机有放回抽样

在[1,2,3,4,5]中抽取一个数，第一次可能抽到2，然后放回2，第二次可能还会抽到二，比如生成了一个新的树的训练集[2,2,3,1,5]

特征随机—从M个特征中随机抽取m个特征

要求：M 远大于m（可以起到降维作用）

森林：包含多个决策树的分类器

如何在sklearn中使用随机森林？

API：sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=‘gini’, max_depth=None, bootstrap=True, random_state=None, min_samples_split=2)

随机森林分类器

n_estimators：integer，optional，默认为10，森林里的树木数量，可选值[120, 200, 300, 500, 800, 1200]

criterion：string，可选，默认为gini系数，分割特征的测量方法，也可以选择为entropy（即信息增益）

max_depth：integer或None，可选，默认为无，设置每棵决策树的最大深度，可选值[5, 8, 15, 25, 30]

max_features=‘auto’：每个决策树的最大特征数量，即如何生成m

如果为’auto’，则对M（即全部特征）开平方根得到m，即max_features = sqrt(n_features)

如果为’sqrt’，则对M（即全部特征）开平方根得到m，即max_features = sqrt(n_features)，和auto相同

如果为’log2’，max_features = log2(n_features)

如果为None，那么max_features = n_features

bootstrap：boolean，optional，默认为true，是否在构建树时使用随机有放回抽样方法\

因为有些参数可以设置，所以可以网格搜索和交叉验证进行调参，提高准确率

示例：在上面jupyter notebook代码中使用随机森林方法对泰坦尼克号乘客生存进行预测

代码：

from sklearn.ensemble import RandomForestClassifier 
from sklearn.model_selection import GridSearchCV 
# 实例化一个随机森林预估器 
estimator = RandomForestClassifier() 
# 模型选择与调优，加入网格搜索和交叉验证 
# 参数准备，随机森林预估器要调优的参数n_estimators，max_depth 
param_dict = {'n_estimators':[120, 200, 300, 500, 800], 'max_depth':  [5, 8, 15, 25, 30]} 
estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3) 
estimator.fit(x_train_new, y_train) 
# 模型评估 
# 方法一：直接比对真实值和预测值 
y_test_predict = estimator.predict(x_test_new) 
print('预测的目标值：\n', y_test_predict) 
print('直接比对真实值和预测值：\n', y_test == y_test_predict) 
# 方法二：计算准确率，求得是测试集在训练集中的结果 
score = estimator.score(x_test_new, y_test) 
print('准确率为：\n', score) 
# 最佳参数：best_params_ 
print("最佳参数：\n", estimator.best_params_) 
# 最佳结果：best_score_，交叉验证是对训练集进行划分 
# 一部分用于训练，一部分用于验证，最佳结果求得是训练部分在验证部分的结果 
print("最佳结果：\n", estimator.best_score_) 
# 最佳估计器：best_estimator_ 
print("最佳估计器：\n", estimator.best_estimator_) 
# 交叉验证结果：cv_results_ 
print("交叉验证结果：\n", estimator.cv_results_) 

结果（部分截图）：

总结：

在四种分类算法中，具有很好的准确率

适合运行在大数据集上，特别是在处理高维特征的样本，因为随机森林预估器默认max_features为auto，即全部特征的开平方根，相当于降维了

学习大纲：