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_20newsgroups
from 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_test
x_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 0
1 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 2
1 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 2
1 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 StandardScaler
In [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.LinearReg ression 线性回归
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：登记事件的ID
xy：坐标
准确性：定位准确性
时间：时间戳
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 StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import pandas as pd
def 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或者score
knn.fit(x_train, y_train)
#预测测试集的所办业务类型
y_pridict = knn.predict(x_test)
print("k近邻算法预测的这些时间的业务类型", y_pridict)
print("k近邻预测的准确率为：", knn.score(x_test, y_test))
return None
if __name__=='__main__':
knncls()
输出结果:
k近邻算法预测的这些时间的业务类型 [6399991653 5606572086 6399991653 ... 9237487147 6424972551 8780655195]
k近邻预测的准确率为： 0.5120173364854216
Process 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 GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import pandas as pd
def 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, 通常会选择10
gc = 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 None
if __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.5486603624901497
Process finished with exit code 0
5.朴素贝叶斯算法
学习目标:
说明条件概率与联合概率
说明贝叶斯公式、以及特征独立的关系
记忆贝叶斯公式
知道拉普拉斯平滑系数
应用贝叶斯公式实现概率的计算
应用
20类新闻文章分类预测
5.1 什么是朴素贝叶斯分类方法
5.2 概率基础
5.2.1 概率(Probability)定义
概率定义为一件事情发生的可能性
扔出一个硬币，结果头像朝上
某天是晴天
P(X) : 取值在[0, 1]
5.2.2 女神是否喜欢计算案例
在讲这两个概率之前我们通过一个例子，来计算一些结果：
问题如下：
- P(喜欢) = 4/7
- P(程序员, 体型匀称) = P(程序员)P(体型匀称)=3/7 * 4/7 =12/49
- P(程序员|喜欢) = 1/2
- P(产品,超重|喜欢) = 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_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
def 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 None
if __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 10
2 0 9 2 10 3 14 4 14 14 12 14 18 8 0 6 6 2 4 4 2 13 11 13
10 15]
真实类别为： [11 10 8 13 13 5 0 7 11 7 2 7 10 13 10 9 15 9 16 4 17 19 12 10
4 0 9 2 10 3 14 4 14 14 3 14 18 8 0 6 6 2 4 4 5 13 11 13
10 11]
预测准确率为： 0.8542624690484613
Process 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.971
3、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 DictVectorizer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.tree import DecisionTreeClassifier, export_graphviz
import pandas as pd
def 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 None
if __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.8350253807106599
Process 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 DictVectorizer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
def 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 None
if __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 总结
在当前所有算法中，具有极好的准确率.
能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维.
能够评估各个特征在分类问题上的重要性.
1948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
