机器学习分类算法

1. 机器学习算法简介1.1 按照学习方式分类1.2 区别1.3 关于监督学习中的分类与回归区别1.4 机器学习开发流程2. 数据集介绍与划分2.1 sklearn数据集介绍2.1.1 分类和回归数据集2.1.2 API2.1.3 返回类型2.1.4 代码分析2.2 转换器和估计器2.2.1转换器2.2.2 估计器(sklearn机器学习算法的实现)2.2.3 估计器工作流程3. K-近邻算法3.1K-近邻算法(KNN)3.1.1 定义3.1.2 距离公式3.2 电影类型分析3.3 K-近邻算法API3.4 案例：预测签到位置3.4.1 分析3.4.2 代码3.4.3 结果分析3.5 总结4 模型选择与调优4.1 为什么需要交叉验证4.2 什么是交叉验证(cross validation)4.3 超参数搜索-网格搜索(Grid Search)4.4 Facebook签到位置预测K值调优5.朴素贝叶斯算法5.1 什么是朴素贝叶斯分类方法5.2 概率基础5.2.1 概率(Probability)定义5.2.2 女神是否喜欢计算案例5.2.3 条件概率与联合概率5.3 贝叶斯公式5.3.1 公式5.3.2 文章分类计算5.3.3 拉普拉斯平滑系数5.3.4 API5.4 案例：20类新闻分类5.4.1 分析5.4.2 代码5.5 总结6.决策树6.1 认识决策树6.2 决策树分类原理详解6.2.1 原理6.2.2 信息熵6.2.2.1 信息熵的定义6.2.2.2 总结（重要）6.2.3 决策树的划分依据之一------信息增益6.2.3.1 定义与公式6.2.3.2 贷款特征重要计算6.2.4 决策树的三种算法实现6.2.5 决策树API6.3 案例：泰坦尼克号乘客生存预测6.3.1 分析6.3.2 保存树的结构到dot文件6.3.3 代码6.4 总结7. 集成学习方法之随机森林7.1 什么是集成学习方法7.2 什么是随机森林7.3 随机森林原理过程7.3.1 为什么采用BootStrap抽样7.3.2 API7.3.3 代码7.4 总结

1. 机器学习算法简介

学习目标:

说明机器学习算法监督学习与无监督学习的区别

说明机器学习算法目标值的两种数据类型

说明监督学习中的分类、回归特点

说明机器学习(数据挖掘)的开发流程

知道数据集的分为训练集和测试集

知道sklearn的转换器和估计器流程

了解sklearn的分类、回归数据集

说明K-近邻算法的距离公式

说明K-近邻算法的超参数K值以及取值问题

说明K-近邻算法的优缺点

应用KNeighborsClassifier实现分类

了解分类算法的评估标准准确率

说明朴素贝叶斯算法的原理

说明朴素贝叶斯算法的优缺点

应用MultinomialNB实现文本分类

应用模型选择与调优

说明决策树算法的原理

说明决策树算法的优缺点

应用DecisionTreeClassifier实现分类

说明随机森林算法的原理

说明随机森林算法的优缺点

应用RandomForestClassifier实现分类

1.1 按照学习方式分类

监督学习(supervised learning)（预测）

定义：输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值(称为回归），或是输出是有限个离散值（称作分类）。

分类: k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络

回归: 线性回归、岭回归

标注 隐马尔可夫模型 (不做要求)

无监督学习(unsupervised learning)

定义：输入数据是由输入特征值所组成。

聚类 k-means

半监督和强化学习

1.2 区别

1.3 关于监督学习中的分类与回归区别

两种数据类型:

离散型数据：由记录不同类别个体的数目所得到的数据，又称计数数据，所有这些数据全部都是整数，而且不能再细分，也不能进一步提高他们的精确度。

连续型数据：变量可以在某个范围内取任一数，即变量的取值可以是连续的，如，长度、时间、质量值等，这类整数通常是非整数，含有小数部分。

注：只要记住一点，离散型是区间内不可分，连续型是区间内可分

结合刚才讲过的数据类型，针对这两个例子的输出结果，得出结论

分类：目标值数据类型为离散型

分类是监督学习的一个核心问题，在监督学习中，当输出变量取有限个离散值时，预测问题变成为分类问题，最基础的便是二分类问题，即判断是非，从两个类别中选择一个作为预测结果；

回归：目标值数据类型为连续型

回归是监督学习的另一个重要问题。回归用于预测输入变量和输出变量之间的关系，输出是连续型的值。

1.4 机器学习开发流程

2. 数据集介绍与划分

学习目标:

知道数据集的分为训练集和测试集

知道sklearn的分类、回归数据集

划分比例：

训练集：70% 80% 75%

测试集：30% 20% 30%

API:

sklearn.model_selection.train_test_split(arrays, *options)

x 数据集的特征值

y 数据集的标签值

test_size 测试集的大小，一般为float

random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。

return ，测试集特征训练集特征值值，训练标签，测试标签(默认随机取)

结合后面的数据集作介绍

2.1 sklearn数据集介绍

2.1.1 分类和回归数据集

(1)分类数据集

sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)

subset: ‘train’或者’test’,‘all’，可选，选择要加载的数据集.训练集的“训练”，测试集的“测试”，两者的“全部”

2.1.2 API

sklearn.datasets 加载获取流行数据集

datasets.load_()

获取小规模数据集，数据包含在datasets里

datasets.fetch_(data_home=None)

获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/

2.1.3 返回类型

load和fetch返回的数据类型datasets.base.Bunch(字典格式)

data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组

target：标签数组，是 n_samples 的一维 numpy.ndarray 数组

DESCR：数据描述

feature_names：特征名,新闻数据，手写数字、回归数据集没有

target_names：标签名

2.1.4 代码分析

from sklearn.datasets import load_iris, load_boston, fetch_20newsgroupsfrom sklearn.model_selection import train_test_split, GridSearchCV#分类数据集lr = load_iris()# print("特征值", lr.data)# print("目标值", lr.target)# #print(lr.DESCR)# print(lr.feature_names)# print(lr.target_names)## #回归数据集# lb = load_boston()# print("特征值：", lb.data)# print("目标值:", lb.target)## #数据量比较大的数据集# news = fetch_20newsgroups(subset='all')# print(news.data)# print(news.target)## #进行数据集的训练集和测试集划分# #返回值有四个部分接收# #x,y 特征值和目标值，train ,test训练集和测试集# #x_train,x_test,y_train,y_testx_train, x_test, y_train, y_test = train_test_split(lr.data, lr.target, test_size=0.3)print("训练集的特征值：", x_train)print("测试集的特征值", x_test)print("训练集的目标值：", y_train)print("测试集的目标值", y_test)

输出结果:

/home/yuyang/anaconda3/envs/tensor1-6/bin/python3.5 "/media/yuyang/Yinux/heima/Machine learning/demo.py"训练集的特征值： [[5.2 3.4 1.4 0.2][6.3 2.8 5.1 1.5][6.9 3.1 4.9 1.5][5.8 2.7 3.9 1.2][5.2 4.1 1.5 0.1][5.9 3.2 4.8 1.8][5.8 2.8 5.1 2.4].......................[4.9 3.1 1.5 0.1]测试集的特征值 [[6.5 3. 5.2 2. ][5.7 4.4 1.5 0.4]......................[5.7 2.6 3.5 1. ]]训练集的目标值： [0 2 1 1 0 1 2 0 2 2 2 1 2 1 2 0 1 2 2 2 1 0 1 1 1 2 2 1 0 2 1 2 2 1 0 2 01 1 2 0 0 1 0 0 1 2 0 0 2 0 0 1 0 1 0 0 0 0 1 1 0 1 2 1 2 1 2 2 2 2 0 2 21 1 0 0 2 0 0 1 0 1 2 0 0 2 2 0 1 2 0 1 1 1 2 2 0 2 0 2 2 2 0]测试集的目标值 [2 0 1 1 1 1 2 0 0 0 2 2 0 0 0 1 2 2 0 0 2 1 1 1 1 0 0 1 2 1 1 1 0 0 2 2 21 2 1 0 0 1 1 1]Process finished with exit code 0

2.2 转换器和估计器

2.2.1转换器

想一下之前做的特征工程的步骤？

1、实例化 (实例化的是一个转换器类(Transformer))

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

我们把特征工程的接口称之为转换器，其中转换器调用有这么几种形式

fit_transform

fit

transform

这几个方法之间的区别是什么呢？我们看以下代码就清楚了

In [1]: from sklearn.preprocessing import StandardScalerIn [2]: std1 = StandardScaler()In [3]: a = [[1,2,3], [4,5,6]]In [4]: std1.fit_transform(a)Out[4]:array([[-1., -1., -1.],[ 1., 1., 1.]])In [5]: std2 = StandardScaler()In [6]: std2.fit(a)Out[6]: StandardScaler(copy=True, with_mean=True, with_std=True)In [7]: std2.transform(a)Out[7]:array([[-1., -1., -1.],[ 1., 1., 1.]])

从中可以看出，fit_transform的作用相当于transform加上fit。但是为什么还要提供单独的fit呢, 我们还是使用原来的std2来进行标准化看看

In [8]: b = [[7,8,9], [10, 11, 12]]In [9]: std2.transform(b)Out[9]:array([[3., 3., 3.],[5., 5., 5.]])In [10]: std2.fit_transform(b)Out[10]:array([[-1., -1., -1.],[ 1., 1., 1.]])`

注:此例说明

fit_transform=fit + transform

fit_transform(a):标准化:以自己a的平均值标准差转换自己

fit(a):计算a的平均值和标准差,transform(b):以a的平均值和标准差去转换b

适用于特征选择,主成分分析,特征抽取

2.2.2 估计器(sklearn机器学习算法的实现)

在sklearn中，估计器(estimator)是一个重要的角色，是一类实现了算法的API

1、用于分类的估计器：

sklearn.neighbors k-近邻算法

sklearn.naive_bayes 贝叶斯

sklearn.linear_model.LogisticRegression 逻辑回归

sklearn.tree 决策树与随机森林

2、用于回归的估计器：

sklearn.linear_model.LinearRegression 线性回归

sklearn.linear_model.Ridge 岭回归

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

2.2.3 估计器工作流程

sklearn.cluster.KMeans 聚类

estimator估计器:实现了大部分算法

fit():训练集训练

predict,score预测,准确率

3. K-近邻算法

学习目标:

说明K-近邻算法的距离公式

说明K-近邻算法的超参数K值以及取值问题

说明K-近邻算法的优缺点

应用KNeighborsClassifier实现分类

了解分类算法的评估标准准确率

应用

Facebook签到位置预测

什么是K-近邻算法

你的“邻居”来推断出你的类别

3.1K-近邻算法(KNN)

3.1.1 定义

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

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

3.1.2 距离公式

两个样本的距离可以通过如下公式计算，又叫欧式距离

3.2 电影类型分析

假设我们有现在几部电影

其中？ 号电影不知道类别，如何去预测？我们可以利用K近邻算法的思想

用?的特征值,和其它6部电影计算距离.eg:(3-18)^ 2 +(104-90)^ 2=20.5

3.3 K-近邻算法API

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

n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数

algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

3.4 案例：预测签到位置

kaggle大赛

数据介绍：

train.csv，test.csv row_id：登记事件的IDxy：坐标准确性：定位准确性 时间：时间戳place_id：业务的ID，这是您预测的目标

3.4.1 分析

对于数据做一些基本处理（这里所做的一些处理不一定达到很好的效果，我们只是简单尝试，有些特征我们可以根据一些特征选择的方式去做处理）

1、缩小数据集范围 DataFrame.query()

2、处理日期数据 pd.to_datetime pd.DatetimeIndex

3、增加分割的日期数据

4、删除没用的日期数据 DataFrame.drop

5、将签到位置少于n个用户的删除

place_count = data.groupby(‘place_id’).count()

tf = place_count[place_count.row_id > 3].reset_index()

data = data[data[‘place_id’].isin(tf.place_id)]

3.4.2 代码

from sklearn.preprocessing import StandardScalerfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.model_selection import train_test_splitimport pandas as pddef knncls():'''K-近邻算法预测用户查询的业务:return:'''data = pd.read_csv("./data/facebook-v-predicting-check-ins/train.csv")#print(data)#1.缩小数据范围data = data.query('x>1.0 & x<1.25 & y>2.5 & y<2.75')#3.把签到位置小于N个人的位置给删除掉place_count = data.groupby('place_id').count()tf = place_count[place_count.row_id > 3].reset_index()data = data[data['place_id'].isin(tf.place_id)]#4.分割数据集到训练集和测试集#取出特征值和目标值#y = data[['place_id']] #目标值y = data['place_id'] #一维数据x = data[['x', 'y', 'accuracy', 'time']]x_train, x_test ,y_train, y_test = train_test_split(x, y, test_size=0.3)#进行数据的标准化处理,测试集和训练集分开标准化std = StandardScaler()#对训练集的特征值作标准化处理x_train = std.fit_transform(x_train)#对测试集的特征值作标准化处理x_test = std.fit_transform(x_test)#5应用网格搜索+交叉验证-K近邻算法去进行调优knn = KNeighborsClassifier(n_neighbors=5)#利用fit和predict或者scoreknn.fit(x_train, y_train)#预测测试集的所办业务类型y_pridict = knn.predict(x_test)print("k近邻算法预测的这些时间的业务类型", y_pridict)print("k近邻预测的准确率为：", knn.score(x_test, y_test))return Noneif __name__=='__main__':knncls()

输出结果:

k近邻算法预测的这些时间的业务类型 [6399991653 5606572086 6399991653 ... 9237487147 6424972551 8780655195]k近邻预测的准确率为： 0.513364854216Process finished with exit code 0

3.4.3 结果分析

1、k值取多大？有什么影响？

k值取很小：容易受到异常点的影响

k值取很大：受到样本均衡的问题

2、性能问题？

距离计算上面，时间复杂度高

3.5 总结

优点：

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

缺点：

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

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

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

4 模型选择与调优

目标

说明交叉验证过程

说明超参数搜索过程

应用GridSearchCV实现算法参数的调优

应用

Facebook签到位置预测调优

4.1 为什么需要交叉验证

交叉验证目的：为了让被评估的模型更加准确可信.

4.2 什么是交叉验证(cross validation)

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

分析:

我们之前知道数据分为训练集和测试集，但是为了让从训练得到模型结果更加准确。做以下处理

训练集：训练集+验证集

测试集：测试集

问题:如何给模型选择最好的参数呢?

4.3 超参数搜索-网格搜索(Grid Search)

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

API:

sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)

对估计器的指定参数值进行详尽搜索

estimator：估计器对象

param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}

cv：指定几折交叉验证

fit：输入训练数据

score：准确率

结果分析：

bestscore:在交叉验证中验证的最好结果

bestestimator：最好的参数模型

cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果

4.4 Facebook签到位置预测K值调优

代码:

from sklearn.model_selection import GridSearchCVfrom sklearn.preprocessing import StandardScalerfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.model_selection import train_test_splitimport pandas as pddef knncls():'''K-近邻算法预测用户查询的业务:return:'''data = pd.read_csv("./data/facebook-v-predicting-check-ins/train.csv")#print(data)#1.缩小数据范围data = data.query('x>1.0 & x<1.25 & y>2.5 & y<2.75')#3.把签到位置小于N个人的位置给删除掉place_count = data.groupby('place_id').count()tf = place_count[place_count.row_id > 3].reset_index()data = data[data['place_id'].isin(tf.place_id)]#4.分割数据集到训练集和测试集#取出特征值和目标值#y = data[['place_id']] #目标值,这样写y是二维数据,knn允许训练,但gc不行,所以写成1维数据y = data['place_id'] #一维数据x = data[['x', 'y', 'accuracy', 'time']]x_train, x_test ,y_train, y_test = train_test_split(x, y, test_size=0.3)#进行数据的标准化处理,测试集和训练集分开标准化std = StandardScaler()#对训练集的特征值作标准化处理x_train = std.fit_transform(x_train)#对测试集的特征值作标准化处理x_test = std.fit_transform(x_test)#5应用网格搜索+交叉验证-K近邻算法去进行调优knn = KNeighborsClassifier(n_neighbors=5)#构造超参数字典#对knn来讲，数据量比较大,k =根号（样本）param = {"n_neighbors": [1, 3, 5, 7, 10]}#估计器是knn;为了看到效果，cv = 2, 通常会选择10gc = GridSearchCV(knn, param_grid=param, cv=2)#gc想当于被包裹的estimator,fit输入数据,进行训练gc.fit(x_train, y_train)#查看模型超参数调优的过程，交叉验证的结果print("在2折交叉验证当中最好的结果：",gc.best_score_)print("选择的最好的模型参数是：", gc.best_estimator_)print("每次交叉验证的验证集的预测结果：", gc.cv_results_)#预测测试集的准确率print("在测试集当中的最终预测结果为：", gc.score(x_test, y_test))return Noneif __name__=='__main__':knncls()

输出结果:

交叉验证当中最好的结果： 0.5160445870629962选择的最好的模型参数是： KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',metric_params=None, n_jobs=None, n_neighbors=10, p=2,weights='uniform')每次交叉验证的验证集的预测结果： {'mean_test_score': array([0.44983955, 0.47829758, 0.5052356 , 0.51418679, 0.51604459]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 10], dtype=object), 'split1_train_score': array([1. , 0.66376715, 0.6239545 , 0.6022081 , 0.57176313]), 'split0_train_score': array([1. , 0.67360164, 0.62653479, 0.6026603 , 0.58475443]), 'split1_test_score': array([0.45310368, 0.48209413, 0.51432469, 0.52353342, 0.52557981]),'split0_test_score': array([0.44663767, 0.47457344, 0.49631984, 0.5050184 , 0.5066912 ]), .........................dtype=int32)}在测试集当中的最终预测结果为： 0.5486603624901497Process finished with exit code 0

5.朴素贝叶斯算法

学习目标:

说明条件概率与联合概率

说明贝叶斯公式、以及特征独立的关系

记忆贝叶斯公式

知道拉普拉斯平滑系数

应用贝叶斯公式实现概率的计算

应用

20类新闻文章分类预测

5.1 什么是朴素贝叶斯分类方法

5.2 概率基础

5.2.1 概率(Probability)定义

概率定义为一件事情发生的可能性

扔出一个硬币，结果头像朝上

某天是晴天

P(X) : 取值在[0, 1]

5.2.2 女神是否喜欢计算案例

在讲这两个概率之前我们通过一个例子，来计算一些结果：

问题如下：

P(喜欢) = 4/7P(程序员, 体型匀称) = P(程序员)P(体型匀称)=3/7 * 4/7 =12/49P(程序员|喜欢) = 1/2P(产品,超重|喜欢) = 1/2 * 1/4 = 1/8

5.2.3 条件概率与联合概率

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

记作：P(A,B)

特性：P(A, B) = P(A)P(B)

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

记作：P(A|B) = P(AB)/P(B)

特性：P(A1,A2|B) = P(A1|B)P(A2|B)

注意：此条件概率的成立，是由于A1,A2相互独立的结果(记忆)

这样我们计算结果为：

p(程序员, 匀称) = P(程序员)P(匀称) =3/7*(4/7) = 12/49 P(产品, 超重|喜欢) = P(产品|喜欢)P(超重|喜欢)=1/2 * 1/4 = 1/8

这个了类似一个条件概率，那么仔细一想，给定文章其实相当于给定什么？结合前面我们将文本特征抽取的时候讲的？所以我们可以理解为:

5.3 贝叶斯公式

5.3.1 公式

公式分为三个部分：

P©：每个文档类别的概率(某文档类别数／总文档数量)

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

计算方法：P(F1│C)=Ni/N （训练文档中去计算）

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

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

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

P(科技|文章1) = P(词1, 词2,词3....词n|科技)P(科技)/P((词1, 词2,词3....词n)P(娱乐|文章1) = P(词1, 词2,词3....词n|娱乐)P(娱乐))/P((词1, 词2,词3....词n)

5.3.2 文章分类计算

假设我们从训练数据集得到如下信息:

计算结果:

科技：P(科技|影院,支付宝,云计算) = ?(影院,支付宝,云计算|科技)∗P(科技)=(8/100)∗(20/100)∗(63/100)∗(30/90) = 0.00456109娱乐：P(娱乐|影院,支付宝,云计算) = ?(影院,支付宝,云计算|娱乐)∗P(娱乐)=(56/121)∗(15/121)∗(0/121)∗(60/90) = 0

思考:我们计算出来某个概率为0，合适吗？

5.3.3 拉普拉斯平滑系数

目的：防止计算出的分类概率为0

P(娱乐|影院,支付宝,云计算) =P(影院,支付宝,云计算|娱乐)P(娱乐) =P(影院|娱乐)*P(支付宝|娱乐)*P(云计算|娱乐)P(娱乐)=(56+1/121+4)(15+1/121+4)(0+1/121+1*4)(60/90) = 0.00002

5.3.4 API

sklearn.naive_bayes.MultinomialNB(alpha = 1.0)

朴素贝叶斯分类

alpha：拉普拉斯平滑系数

5.4 案例：20类新闻分类

5.4.1 分析

分割数据集

tfidf进行的特征抽取

朴素贝叶斯预测

5.4.2 代码

from sklearn.datasets import fetch_20newsgroupsfrom sklearn.model_selection import train_test_splitfrom sklearn.feature_extraction.text import TfidfVectorizerfrom sklearn.naive_bayes import MultinomialNBdef nbcls():"""朴素贝叶斯对新闻数据集进行预测:return:"""# 获取新闻的数据，20个类别,包含特征值和目标值news = fetch_20newsgroups(subset='all')# 进行数据集分割x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.3)# 对于文本数据，进行特征抽取tfidf = TfidfVectorizer()x_train = tfidf.fit_transform(x_train)# 这里打印出来的列表是：训练集当中的所有不同词的组成的一个列表a = tfidf.get_feature_names()# print(x_train.toarray())# 不能调用fit_transform,否则会出错,用x_train去转换,因为预测文档是基于训练集预测的x_test = tfidf.transform(x_test)b = tfidf.get_feature_names()#print(a==b) #a!=b# estimator估计器流程mlb = MultinomialNB(alpha=1.0)mlb.fit(x_train, y_train)# 进行预测y_predict = mlb.predict(x_test)print("预测每篇文章的类别：", y_predict[:50]) #打印前50个print("真实类别为：", y_test[:50])#打印前50个print("预测准确率为：", mlb.score(x_test, y_test))return Noneif __name__=='__main__':nbcls()

输出结果:

预测每篇文章的类别： [11 10 8 13 13 13 0 7 11 7 2 7 10 13 10 9 15 9 16 4 17 16 11 102 0 9 2 10 3 14 4 14 14 12 14 18 8 0 6 6 2 4 4 2 13 11 1310 15]真实类别为： [11 10 8 13 13 5 0 7 11 7 2 7 10 13 10 9 15 9 16 4 17 19 12 104 0 9 2 10 3 14 4 14 14 3 14 18 8 0 6 6 2 4 4 5 13 11 1310 11]预测准确率为： 0.8542624690484613Process finished with exit code 0

5.5 总结

优点：

朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。

对缺失数据不太敏感，算法也比较简单，常用于文本分类。

分类准确度高，速度快

缺点：

由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

6.决策树

目标:

说明信息熵的公式以及作用

说明信息增益的公式作用

应用信息增益实现计算特征的不确定性减少程度

了解决策树的三种算法实现

应用:

泰坦尼克号乘客生存预测

怎么理解这句话？通过一个对话例子

6.1 认识决策树

决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-then结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

怎么理解这句话？通过一个对话例子

想一想这个女生为什么把年龄放在最上面判断！！！！！！！！！

6.2 决策树分类原理详解

为了更好理解决策树具体怎么分类的，我们通过一个问题例子？

问题：如何对这些客户进行分类预测？你是如何去划分？

有可能你的划分是这样的

那么我们怎么知道这些特征哪个更好放在最上面，那么决策树的真是划分是这样的

6.2.1 原理

信息熵、信息增益等

6.2.2 信息熵

那来玩个猜测游戏，猜猜这32支球队那个是冠军。并且猜测错误付出代价。每猜错一次给一块钱，告诉我是否猜对了，那么我需要掏多少钱才能知道谁是冠军？ （前提是：不知道任意球队的信息、历史比赛记录、实力等）

为了使代价最小，可以使用二分法猜测：

我可以把球编上号，从1到32，然后提问：冠 军在1-16号吗？依次询问，只需要五次，就可以知道结果。

我们来看这个式子：

32支球队，log32=5比特

64支球队，log64=6比特

香农指出，它的准确信息量应该是，p为每个球队获胜的概率（假设概率相等，都为1/32），我们不用钱去衡量这个代价了，香浓指出用比特：

H = -(p1logp1 + p2logp2 + ... + p32log32) = - log32

6.2.2.1 信息熵的定义

H的专业术语称之为信息熵，单位为比特。

“谁是世界杯冠军”的信息量应该比5比特少，特点（重要）：

当这32支球队夺冠的几率相同时，对应的信息熵等于5比特

只要概率发生任意变化，信息熵都比5比特大

6.2.2.2 总结（重要）

信息和消除不确定性是相联系的

当我们得到的额外信息（球队历史比赛情况等等）越多的话，那么我们猜测的代价越小（猜测的不确定性减小）

问题：回到我们前面的贷款案例，怎么去划分？可以利用当得知某个特征（比如是否有房子）之后，我们能够减少的不确定性大小。越大我们可以认为这个特征很重要。那怎么去衡量减少的不确定性大小呢？

6.2.3 决策树的划分依据之一------信息增益

6.2.3.1 定义与公式

特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差，即公式为：

公式的详细解释：

注：信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度

6.2.3.2 贷款特征重要计算

我们以年龄特征来计算：

1、g(D, 年龄) = H(D) -H(D|年龄) = 0.971-[5/15H(青年)+5/15H(中年)+5/15H(老年]2、H(D) = -(6/15log(6/15)+9/15log(9/15))=0.9713、H(青年) = -(3/5log(3/5) +2/5log(2/5))H(中年)=-(3/5log(3/5) +2/5log(2/5))H(老年)=-(4/5og(4/5)+1/5log(1/5))

6.2.4 决策树的三种算法实现

决策树的原理不止信息增益这一种，还有其他方法。但是原理都类似。

ID3:

信息增益 最大的准则

C4.5:

信息增益比 最大的准则

CART:

分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则

优势：划分更加细致（从后面例子的树显示来理解）

6.2.5 决策树API

class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)

决策树分类器

criterion:默认是’基尼’系数，也可以选择信息增益的熵’entropy’

max_depth:树的深度大小

random_state:随机数种子

其中会有些超参数：max_depth:树的深度大小

其它超参数结合随机森林讲解

6.3 案例：泰坦尼克号乘客生存预测

泰坦尼克号数据:

在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。这里使用的数据集是由各种研究人员开始的。其中包括许多研究人员创建的旅客名单，由Michael A. Findlay编辑。我们提取的数据集中的特征是票的类别，存活，乘坐班，年龄，登陆，home.dest，房间，票，船和性别。

1、乘坐班是指乘客班（1，2，3），是社会经济阶层的代表。

2、其中age数据存在缺失。

原始数据

6.3.1 分析

选择我们认为重要的几个特征 [‘pclass’, ‘age’, ‘sex’]

填充缺失值

特征中出现类别符号，需要进行one-hot编码处理(DictVectorizer)

x.to_dict(orient=“records”) 需要将数组特征转换成字典数据

数据集划分

决策树分类预测

6.3.2 保存树的结构到dot文件

1、sklearn.tree.export_graphviz() 该函数能够导出DOT格式

tree.export_graphviz(estimator,out_file='tree.dot’,feature_names=[‘’,’’])

2、工具:(能够将dot文件转换为pdf、png)

安装graphviz

ubuntu:sudo apt-get install graphviz Mac:brew install graphviz

3、运行命令

然后我们运行这个命令

dot -Tpng tree.dot -o tree.png

6.3.3 代码

from sklearn.feature_extraction import DictVectorizerfrom sklearn.model_selection import train_test_split, GridSearchCVfrom sklearn.tree import DecisionTreeClassifier, export_graphvizimport pandas as pddef decisioncls():"""决策树进行泰坦尼克号乘客生存预测:return:"""# 1、获取数据taitan = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")# 2、数据的处理x = taitan[['pclass', 'age', 'sex']]y = taitan['survived']#print(x, y)# 填充,缺失值需要处理，将特征当中有类别的这些特征进行字典特征抽取x['age'].fillna(x['age'].mean(), inplace=True)#特征类别数据————>one-hot编码dic = DictVectorizer(sparse=False)# 对于x转换成字典数据x.to_dict(orient="records");将存储多个用户数据的二维数数组转换为字典# [["lst","29","femal"],[]]---->[{"pclass": "1st", "age": 29.00, "sex": "female"}, {}]#再进行one-hot编码x = dic.fit_transform(x.to_dict(orient="records"))print(dic.get_feature_names())print(x)# 3.分割训练集合测试集x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)# 4.进行决策树的建立和预测dc = DecisionTreeClassifier(max_depth=5)dc.fit(x_train, y_train)print("决策树预测的准确率为：", dc.score(x_test, y_test))#导出到dot文件export_graphviz(dc, out_file="./tree.dot",feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', '女性', '男性'])return Noneif __name__=='__main__':decisioncls()

输出结果:

['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male'][[29.1.0.0.1.0. ][ 2.1.0.0.1.0. ][30.1.0.0.0.1. ]...[31.19418104 0.0.1.0.1. ][31.19418104 0.0.1.1.0. ][31.19418104 0.0.1.0.1. ]]决策树预测的准确率为： 0.8350253807106599Process finished with exit code 0

决策树png:

6.4 总结

优点：

简单的理解和解释，树木可视化。

缺点：

决策树学习不能很好地推广数据的过于复杂的树，这被称为过拟合。

改进：

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

注：企业用决策树算法，由于决策树很好的分析能力，在决策过程应用较多， 可以选择特征

7. 集成学习方法之随机森林

学习目标:

说名随机森林每棵决策树的建立过程

知道为什么需要随机有放回(Bootstrap)的抽样

说明随机森林的超参数

应用

泰坦尼克号乘客生存预测

7.1 什么是集成学习方法

集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。

7.2 什么是随机森林

在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。

例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终投票结果就是True

7.3 随机森林原理过程

学习算法根据下列算法而建造每棵树：

用N来表示训练用例（样本）的个数，M表示特征数目。

1、一次随机选出一个样本，重复N次， （有可能出现重复的样本）

2、随机去选出m个特征, m <<M，建立决策树

采取bootstrap抽样

7.3.1 为什么采用BootStrap抽样

为什么要随机抽样训练集？

如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的

为什么要有放回地抽样？

如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。

7.3.2 API

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

随机森林分类器

n_estimators：integer，optional（default = 10）森林里的树木数量120,200,300,500,800,1200

criteria：string，可选（default =“gini”）分割特征的测量方法

max_depth：integer或None，可选（默认=无）树的最大深度 5,8,15,25,30

max_features="auto”,每个决策树的最大特征数量

If “auto”, then max_features=sqrt(n_features).

If “sqrt”, then max_features=sqrt(n_features) (same as “auto”).

If “log2”, then max_features=log2(n_features).

If None, then max_features=n_features.

bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样

min_samples_split:节点划分最少样本数

min_samples_leaf:叶子节点的最小样本数

超参数：n_estimator, max_depth, min_samples_split,min_samples_leaf

7.3.3 代码

from sklearn.feature_extraction import DictVectorizerfrom sklearn.model_selection import train_test_split, GridSearchCVfrom sklearn.ensemble import RandomForestClassifierimport pandas as pddef randomforest():"""随机森林进行泰坦尼克号乘客生存预测:return:"""# 1、获取数据taitan = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")# 2、数据的处理x = taitan[['pclass', 'age', 'sex']]y = taitan['survived']#print(x, y)# 填充,缺失值需要处理，将特征当中有类别的这些特征进行字典特征抽取x['age'].fillna(x['age'].mean(), inplace=True)#特征类别数据————>one-hot编码dic = DictVectorizer(sparse=False)# 对于x转换成字典数据x.to_dict(orient="records");将存储多个用户数据的二维数数组转换为字典# [["lst","29","femal"],[]]---->[{"pclass": "1st", "age": 29.00, "sex": "female"}, {}]#再进行one-hot编码x = dic.fit_transform(x.to_dict(orient="records"))# 3.分割训练集合测试集x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)rf = RandomForestClassifier()# 6. 构造超参数字典param = {"n_estimators": [120, 200, 300, 500, 1000, 1200],"max_depth": [5, 8, 15, 25, 30],"min_samples_split": [2, 3, 5]}# 交叉验证gc = GridSearchCV(rf, param_grid=param, cv=2)gc.fit(x_train, y_train)print("随机森林的准确率:", gc.score(x_test, y_test))print("随机森林选择的参数:", gc.best_estimator_)return Noneif __name__=='__main__':randomforest()

输出结果:

随机森林的准确率: 0.8121827411167513随机森林选择的参数: RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',max_depth=5, max_features='auto', max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,min_samples_leaf=1, min_samples_split=3,min_weight_fraction_leaf=0.0, n_estimators=120, n_jobs=None,oob_score=False, random_state=None, verbose=0,warm_start=False)Process finished with exit code 0

7.4 总结

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

能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维.

能够评估各个特征在分类问题上的重要性.