机器学习分类算法
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 总结
在当前所有算法中,具有极好的准确率.
能够有效地运行在大数据集上,处理具有高维特征的输入样本,而且不需要降维.
能够评估各个特征在分类问题上的重要性.
如果觉得《机器学习实战之分类算法(K-近邻/朴素贝叶斯/决策树/随机森林)》对你有帮助,请点赞、收藏,并留下你的观点哦!