文章目录
1.转换器与预估器
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.]])
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、用于无监督学习的估计器
- sklearn.cluster.KMeans 聚类
3 估计器工作流程
2.K-近邻算法
1 什么是K-近邻算法
- 根据你的“邻居”来推断出你的类别
1.1 K-近邻算法(KNN)概念
K Nearest Neighbor算法又叫KNN算法,这个算法是机器学习里面一个比较经典的算法, 总体来说KNN算法是相对比较容易理解的算法
- 定义
如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。
来源:KNN算法最早是由Cover和Hart提出的一种分类算法
- 距离公式
两个样本的距离可以通过如下公式计算,又叫欧式距离 ,关于距离公式会在后面进行讨论
1.2 电影类型分析
假设我们现在有几部电影
其中? 号电影不知道类别,如何去预测?我们可以利用K近邻算法的思想
分别计算每个电影和被预测电影的距离,然后求解
1.3 KNN算法流程总结
1)计算已知类别数据集中的点与当前点之间的距离
2)按距离递增次序排序
3)选取与当前点距离最小的k个点
4)统计前k个点所在的类别出现的频率
5)返回前k个点出现频率最高的类别作为当前点的预测分类
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方法的值来决定最合适的算法。 (不同实现方式影响效率)
2.模型选择与调优
交叉验证目的:为了让被评估的模型更加准确可信
交叉验证:将拿到的训练数据,分为训练和验证集。以下图为例:将数据分成5份,其中一份作为验证集。然后经过5次(组)的测试,每次都更换不同的验证集。即得到5组模型的结果,取平均值作为最终结果。又称5折交叉验证。
分析: 我们之前知道数据分为训练集和测试集,但是**为了让从训练得到模型结果更加准确。**做以下处理
- 训练集:训练集+验证集
- 测试集:测试集
问题:那么这个只是对于参数得出更好的结果,那么怎么选择或者调优参数呢?
超参数搜索-网格搜索(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:每次交叉验证后的验证集准确率结果和训练集准确率结果
3 用KNN算法对鸢尾花进行分类
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
def knn_iris():
'''
用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, test_size=0.2)
# 3.特征工程标准化 此数据不用做降维处理
transfer = StandardScaler()
# fit() 计算 每一列的平均值、标准差
# transform() (x-mean)/std进行最终的转换
x_train = transfer.fit_transform(x_train)
# 对测试集进行标准化,训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换
x_test = transfer.transform(x_test)
# 4.KNN算法预估器
estimator = KNeighborsClassifier(n_neighbors=2)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1:直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)
return None
4 用KNN算法分类,添加网格搜索和交叉验证
def knn_iris_gscn():
'''
用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, test_size=0.2)
# 3.特征工程标准化 此数据不用做降维处理
transfer = StandardScaler()
# fit() 计算 每一列的平均值、标准差
# transform() (x-mean)/std进行最终的转换
x_train = transfer.fit_transform(x_train)
# 对测试集进行标准化,训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换
x_test = transfer.transform(x_test)
# 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离
estimator = KNeighborsClassifier()
# 加入网格搜索和交叉验证
# 参数准备
params_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
# estimator:估计器对象 param_grid:估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
estimator = GridSearchCV(estimator, param_grid=params_dict, cv=10)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1:直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, 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_)
return None
# 运行结果
y_predict:
[0 2 1 2 1 1 1 1 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 2]
y_test:
[0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 2 1 0 2 0 1 2 0 2 2 2 2]
直接对比真实值和预测值:
[ True True True True True True True False True True True True
True True True True True True False True True True True True
True True True True True True]
准确率为:
0.9333333333333333
最佳参数
{'n_neighbors': 5}
最佳结果
0.9666666666666666
最佳估计器
KNeighborsClassifier()
交叉验证结果
{'mean_fit_time': array([0.00059471, 0.00040169, 0.00039732, 0.00049963, 0.00039873,
0.00059736]), 'std_fit_time': array([0.00048576, 0.00049201, 0.00048692, 0.00049964, 0.00048834,
0.00048775]), 'mean_score_time': array([0.00100403, 0.00099268, 0.00089741, 0.00099623, 0.0010962 ,
0.0010021 ]), 'std_score_time': array([1.94739385e-05, 1.83725301e-05, 2.99643138e-04, 4.43773610e-04,
2.95656031e-04, 1.20468404e-05]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
mask=[False, False, False, False, False, False],
fill_value='?',
dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([1., 1., 1., 1., 1., 1.]), 'split1_test_score': array([0.91666667, 0.91666667, 1. , 1. , 0.91666667,
0.91666667]), 'split2_test_score': array([1. , 0.91666667, 1. , 1. , 1. ,
1. ]), 'split3_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
0.91666667]), 'split4_test_score': array([0.91666667, 1. , 1. , 1. , 1. ,
1. ]), 'split5_test_score': array([1., 1., 1., 1., 1., 1.]), 'split6_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
0.91666667]), 'split7_test_score': array([0.83333333, 0.83333333, 0.91666667, 0.91666667, 0.91666667,
0.91666667]), 'split8_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
0.91666667]), 'split9_test_score': array([1., 1., 1., 1., 1., 1.]), 'mean_test_score': array([0.94166667, 0.94166667, 0.96666667, 0.96666667, 0.95833333,
0.95833333]), 'std_test_score': array([0.05335937, 0.05335937, 0.04082483, 0.04082483, 0.04166667,
0.04166667]), 'rank_test_score': array([5, 5, 1, 1, 3, 3])}
Process finished with exit code 0
5 facebook案例
数据介绍:将根据用户的位置,准确性和时间戳预测用户正在查看的业务。
train.csv,test.csv
row_id:登记事件的ID
xy:坐标
准确性:定位准确性
时间:时间戳
place_id:业务的ID,这是您预测的目标
分析
-
对于数据做一些基本处理(这里所做的一些处理不一定达到很好的效果,我们只是简单尝试,有些特征我们可以根据一些特征选择的方式去做处理)
-
1、缩小数据集范围 DataFrame.query()
-
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)]
-
-
分割数据集
-
标准化处理
-
k-近邻预测
import pandas as pd
# 1.获取数据 data = pd.read_csv("../resource/FBlocation/train.csv")
data.head()
row_id x y accuracy time place_id 0 0 0.7941 9.0809 54 470702 8523065625 1 1 5.9567 4.7968 13 186555 1757726713 2 2 8.3078 7.0407 74 322648 1137537235 3 3 7.3665 2.5165 65 704587 6567393236 4 4 4.0961 1.1307 31 472130 7440663949 # 2.基本的数据处理 # 1)缩小数据范围 data = data.query("x < 2.5 & x > 2 & y < 1.5 & y > 1.0")
data.head()
row_id x y accuracy time place_id 112 112 2.2360 1.3655 66 623174 7663031065 180 180 2.2003 1.2541 65 610195 2358558474 367 367 2.4108 1.3213 74 579667 6644108708 874 874 2.0822 1.1973 320 143566 3229876087 1022 1022 2.0160 1.1659 65 207993 3244363975 # 2) 处理时间特征 time_value = pd.to_datetime(data["time"], unit="s")
date = pd.DatetimeIndex(time_value.values)
data["day"] = date.day
data["weekday"] = date.weekday
data["hour"] = date.hour
data.head()
row_id x y accuracy time place_id day weekday hour 112 112 2.2360 1.3655 66 623174 7663031065 8 3 5 180 180 2.2003 1.2541 65 610195 2358558474 8 3 1 367 367 2.4108 1.3213 74 579667 6644108708 7 2 17 874 874 2.0822 1.1973 320 143566 3229876087 2 4 15 1022 1022 2.0160 1.1659 65 207993 3244363975 3 5 9 # 3) 过滤签到次数少的地点 place_count = data.groupby("place_id").count()["row_id"] data.groupby("place_id").count().head()
row_id x y accuracy time day weekday hour place_id 1012165853 1 1 1 1 1 1 1 1 1013991737 3 3 3 3 3 3 3 3 1014605271 28 28 28 28 28 28 28 28 1015645743 4 4 4 4 4 4 4 4 1017236154 31 31 31 31 31 31 31 31 place_count[place_count>3]
place_id 1014605271 28 1015645743 4 1017236154 31 1024951487 5 1028119817 4 ... 9936666116 140 9954155328 8 9980625005 16 9994257798 25 9996671132 18 Name: row_id, Length: 950, dtype: int64
data_final = data[data["place_id"].isin(place_count[place_count > 3].index.values)] data_final.head()
row_id x y accuracy time place_id day weekday hour 112 112 2.2360 1.3655 66 623174 7663031065 8 3 5 367 367 2.4108 1.3213 74 579667 6644108708 7 2 17 874 874 2.0822 1.1973 320 143566 3229876087 2 4 15 1022 1022 2.0160 1.1659 65 207993 3244363975 3 5 9 1045 1045 2.3859 1.1660 498 503378 6438240873 6 1 19 # 筛选特征值和目标值 x=data_final[["x","y","accuracy","day","weekday","hour"]] y=data_final["place_id"]
x.head()
x y accuracy day weekday hour 112 2.2360 1.3655 66 8 3 5 367 2.4108 1.3213 74 7 2 17 874 2.0822 1.1973 320 2 4 15 1022 2.0160 1.1659 65 3 5 9 1045 2.3859 1.1660 498 6 1 19 y.head()
112 7663031065 367 6644108708 874 3229876087 1022 3244363975 1045 6438240873 Name: place_id, dtype: int64
#数据集划分 from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y)
x_train.head()
x y accuracy day weekday hour 13122222 2.3133 1.0623 62 6 1 11 15703514 2.3584 1.0905 60 7 2 0 3404369 2.3267 1.0723 71 4 6 18 5787611 2.3561 1.3800 68 1 3 18 22409969 2.4931 1.2487 56 2 4 19 x_test.head()
x y accuracy day weekday hour 10194068 2.3313 1.2534 88 7 2 16 22726291 2.1479 1.2861 158 6 1 4 14687970 2.3223 1.1362 65 5 0 6 13207637 2.0373 1.0999 68 6 1 13 18514319 2.0160 1.3451 19 6 1 13 x_train
x y accuracy day weekday hour 13122222 2.3133 1.0623 62 6 1 11 15703514 2.3584 1.0905 60 7 2 0 3404369 2.3267 1.0723 71 4 6 18 5787611 2.3561 1.3800 68 1 3 18 22409969 2.4931 1.2487 56 2 4 19 ... ... ... ... ... ... ... 8280341 2.4758 1.4988 68 6 1 10 18168861 2.1059 1.3524 65 3 5 7 18417469 2.3339 1.1413 8 4 6 16 22652277 2.2625 1.3795 56 8 3 10 1112162 2.3827 1.3720 63 9 4 7 60682 rows × 6 columns
from sklearn.preprocessing import StandardScaler from sklearn.neighbors import KNeighborsClassifier from sklearn.model_selection import GridSearchCV
# 3.特征工程标准化 此数据不用做降维处理 transfer = StandardScaler() # fit() 计算 每一列的平均值、标准差 # transform() (x-mean)/std进行最终的转换 x_train = transfer.fit_transform(x_train) # 对测试集进行标准化,训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换 x_test = transfer.transform(x_test) # 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离 estimator = KNeighborsClassifier() # 加入网格搜索和交叉验证 # 参数准备 params_dict = {"n_neighbors":[5,7,9]} # estimator:估计器对象 param_grid:估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率 estimator = GridSearchCV(estimator, param_grid=params_dict, cv=3) estimator.fit(x_train, y_train) # 5.模型评估 #方法1:直接对比真实值和与测试 y_predict = estimator.predict(x_test) print("y_predict:\n",y_predict) print("y_test:\n", y_test) print("直接对比真实值和预测值:\n",y_predict==y_test) #方法2:计算准确率 score = estimator.score(x_test, 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_)
E:\Program Files\Environment\Anaconda3\lib\site-packages\sklearn\model_selection\_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3. warnings.warn( y_predict: [2585551753 5111412226 3588028567 ... 6396652784 3157530019 8812115701] y_test: 10194068 2585551753 22726291 5111412226 14687970 6940115252 13207637 5781604363 18514319 6171384989 ... 6271017 5541564636 18742421 5529091830 15255113 6828787147 21947752 2809108094 26200146 8812115701 Name: place_id, Length: 20228, dtype: int64 直接对比真实值和预测值: 10194068 True 22726291 True 14687970 False 13207637 True 18514319 False ... 6271017 False 18742421 False 15255113 False 21947752 False 26200146 True Name: place_id, Length: 20228, dtype: bool 准确率为: 0.3637037769428515 最佳参数 {'n_neighbors': 7} 最佳结果 0.33497576141406077 最佳估计器 KNeighborsClassifier(n_neighbors=7) 交叉验证结果 {'mean_fit_time': array([0.07247265, 0.06882707, 0.06881801]), 'std_fit_time': array([1.24466489e-03, 1.65780462e-05, 1.75561285e-06]), 'mean_score_time': array([0.76148359, 0.78323086, 0.85836903]), 'std_score_time': array([0.02202489, 0.00621847, 0.07285544]), 'param_n_neighbors': masked_array(data=[5, 7, 9], mask=[False, False, False], fill_value='?', dtype=object), 'params': [{'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}], 'split0_test_score': array([0.33710698, 0.33582163, 0.33112517]), 'split1_test_score': array([0.33227864, 0.33257527, 0.32817521]), 'split2_test_score': array([0.33391012, 0.33653038, 0.33217976]), 'mean_test_score': array([0.33443191, 0.33497576, 0.33049338]), 'std_test_score': array([0.0020054 , 0.00172189, 0.00169479]), 'rank_test_score': array([2, 1, 3])}
5 小结
- K-近邻算法简介【了解】
- 定义:就是通过你的"邻居"来判断你属于哪个类别
- 如何计算你到你的"邻居"的距离:一般时候,都是使用欧氏距离
3 朴素贝叶斯算法
1 什么是朴素贝叶斯分类方法
2 概率基础
2.1 概率(Probability)定义
- 概率定义为一件事情发生的可能性
- 扔出一个硬币,结果头像朝上
- 某天是晴天
- P(X) : 取值在[0, 1]
2.2 女神是否喜欢计算案例
在讲这两个概率之前我们通过一个例子,来计算一些结果:
- 问题如下:
那么其中有些问题我们计算的结果不正确,或者不知道计算,我们有固定的公式去计算
2.3 条件概率与联合概率
- 联合概率:包含多个条件,且所有条件同时成立的概率
- 记作:P(A,B)
- 特性:P(A, B) = P(A)P(B)
- 条件概率:就是事件A在另外一个事件B已经发生条件下的发生概率
- 记作:P(A|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
那么,我们知道了这些知识之后,继续回到我们的主题中。朴素贝叶斯如何分类,这个算法经常会用在文本分类,那就来看文章分类是一个什么样的问题?
3 贝叶斯公式
3.1 公式
那么这个公式如果应用在文章分类的场景当中,我们可以这样看:
公式分为三个部分:
- P©:每个文档类别的概率(某文档类别数/总文档数量)
- P(W│C):给定类别下特征(被预测文档中出现的词)的概率
- 计算方法:P(F1│C)=Ni/N (训练文档中去计算)
- Ni为该F1词在C类别所有文档中出现的次数
- N为所属类别C下的文档所有词出现的次数和
- 计算方法:P(F1│C)=Ni/N (训练文档中去计算)
- P(F1,F2,…) 预测文档中每个词的概率
如果计算两个类别概率比较:
所以我们只要比较前面的大小就可以,得出谁的概率大
3.2 文章分类计算
例一
P(Tokyo|C)=0,这时要加入拉普拉斯平滑系数
比较最终算的两个值那个大救赎有哪一类
例二
- 假设我们从训练数据集得到如下信息
- 计算结果
科技:P(科技|影院,支付宝,云计算) = 𝑃(影院,支付宝,云计算|科技)∗P(科技)=(8/100)∗(20/100)∗(63/100)∗(30/90) = 0.00456109
娱乐:P(娱乐|影院,支付宝,云计算) = 𝑃(影院,支付宝,云计算|娱乐)∗P(娱乐)=(56/121)∗(15/121)∗(0/121)∗(60/90) = 0
思考:我们计算出来某个概率为0,合适吗?
3.3 拉普拉斯平滑系数
目的:防止计算出的分类概率为0
P(娱乐|影院,支付宝,云计算) =P(影院,支付宝,云计算|娱乐)P(娱乐) =P(影院|娱乐)*P(支付宝|娱乐)*P(云计算|娱乐)
3.4 API
- sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
- 朴素贝叶斯分类
- alpha:拉普拉斯平滑系数
4 案例
def nb_news():
'''
用朴素贝叶斯算法对新闻进行分类
:return:
'''
# 1.获取数据
news = fetch_20newsgroups(subset="all")
# 2.划分数据集
x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, train_size=0.25)
# 3.特征工程 特征抽取-TfidfVectorizer
transfer = TfidfVectorizer()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)
# 4.朴素贝叶斯算法预估器
estimator = MultinomialNB()
estimator.fit(x_train, y_train)
# 5.模型评估
#方法一: 直接对比真实值和预测值
y_predict = estimator.predict(x_test)
print("y_predict:\n",y_predict)
print("直接对比真实值和预测值:\n",y_test == y_predict)
#方法二: 计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n",score)
return None
# 运算结果
y_predict:
[ 3 3 5 ... 11 6 7]
直接对比真实值和预测值:
[False True True ... False True True]
准确率为:
0.7384506544039618
4 决策树
1 认识决策树
决策树思想的来源非常朴素,程序设计中的条件分支结构就是if-then结构,最早的决策树就是利用这类结构分割数据的一种分类学习方法
怎么理解这句话?通过一个对话例子
想一想这个女生为什么把年龄放在最上面判断!!!!!!!!!
1.1 决策树分类原理详解
为了更好理解决策树具体怎么分类的,我们通过一个问题例子?
问题:如何对这些客户进行分类预测?你是如何去划分?
有可能你的划分是这样的
那么我们怎么知道这些特征哪个更好放在最上面,那么决策树的真是划分是这样的
2 信息增益
如果一个系统是确定的为1,信息熵最小
如果一个系统每个概率相同,信息熵最大
定义与公式
特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差,即公式为:
公式的详细解释:
注:信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度
贷款特征重要计算
- 我们以年龄特征来计算:
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))
我们以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 作为划分的第一个特征。找信息增益最大的,这样我们就可以一棵树慢慢建立
决策树的三种算法实现
当然决策树的原理不止信息增益这一种,还有其他方法。但是原理都类似,我们就不去举例计算。
- ID3
- 信息增益 最大的准则
- C4.5
- 信息增益比 最大的准则
- CART
- 分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
- 优势:划分更加细致(从后面例子的树显示来理解)
决策树API
- class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)
- 决策树分类器
- criterion:默认是’gini’系数,也可以选择信息增益的熵’entropy’
- max_depth:树的深度大小
- random_state:随机数种子
- 其中会有些超参数:max_depth:树的深度大小
- 其它超参数我们会结合随机森林讲解
保存树的结构到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
3 用决策树对鸢尾花进行分类
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz
def decision_iris():
'''
用决策树对鸢尾花进行分类
:return:
'''
# 1.获取数据集
iris = load_iris()
# 2.划分数据集
x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target)
# 3.决策树预估器
estimator = DecisionTreeClassifier(criterion="entropy")
estimator.fit(x_train,y_train)
# 4.模型评估
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)
export_graphviz(estimator, out_file="decision_tree_ picture/iris_tree.dot", feature_names=iris.feature_names)
return None
4 案例:泰坦尼克号乘客生存预测
- 泰坦尼克号数据
在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。这里使用的数据集是由各种研究人员开始的。其中包括许多研究人员创建的旅客名 单,由Michael A. Findlay编辑。我们提取的数据集中的特征是票的类别,存活,乘坐班,年龄,登陆,home.dest,房间,票,船和性别。
1、乘坐班是指乘客班(1,2,3),是社会经济阶层的代表。
2、其中age数据存在缺失。
import pandas as pd
# 1.获取数据
titanic = pd.read_csv("../resource/titanic/titanic.csv")
# 2.数据处理
# 缺失值处理
# 特征值->字典类型
# 3.准备好特征值 目标值
# 4.划分数据集
# 5.特征工程
# 6.决策树预估器流程
# 7.模型评估
titanic.head()
row.names | pclass | survived | name | age | embarked | home.dest | room | ticket | boat | sex | |
---|---|---|---|---|---|---|---|---|---|---|---|
0 | 1 | 1st | 1 | Allen, Miss Elisabeth Walton | 29.0000 | Southampton | St Louis, MO | B-5 | 24160 L221 | 2 | female |
1 | 2 | 1st | 0 | Allison, Miss Helen Loraine | 2.0000 | Southampton | Montreal, PQ / Chesterville, ON | C26 | NaN | NaN | female |
2 | 3 | 1st | 0 | Allison, Mr Hudson Joshua Creighton | 30.0000 | Southampton | Montreal, PQ / Chesterville, ON | C26 | NaN | (135) | male |
3 | 4 | 1st | 0 | Allison, Mrs Hudson J.C. (Bessie Waldo Daniels) | 25.0000 | Southampton | Montreal, PQ / Chesterville, ON | C26 | NaN | NaN | female |
4 | 5 | 1st | 1 | Allison, Master Hudson Trevor | 0.9167 | Southampton | Montreal, PQ / Chesterville, ON | C22 | NaN | 11 | male |
# 筛选特征值和目标值
x = titanic[["pclass", "age", "sex"]]
y = titanic["survived"]
x
pclass | age | sex | |
---|---|---|---|
0 | 1st | 29.0000 | female |
1 | 1st | 2.0000 | female |
2 | 1st | 30.0000 | male |
3 | 1st | 25.0000 | female |
4 | 1st | 0.9167 | male |
... | ... | ... | ... |
1308 | 3rd | NaN | male |
1309 | 3rd | NaN | male |
1310 | 3rd | NaN | male |
1311 | 3rd | NaN | female |
1312 | 3rd | NaN | male |
1313 rows × 3 columns
y.head()
0 1
1 0
2 0
3 0
4 1
Name: survived, dtype: int64
# 2.数据处理
# 1)缺失值处理
x["age"].fillna(x["age"].mean(), inplace=True)
x.head()
pclass | age | sex | |
---|---|---|---|
0 | 1st | 29.0000 | female |
1 | 1st | 2.0000 | female |
2 | 1st | 30.0000 | male |
3 | 1st | 25.0000 | female |
4 | 1st | 0.9167 | male |
# 2)转换成字典
x = x.to_dict(orient="records")
x[:5]
[{'pclass': '1st', 'age': 29.0, 'sex': 'female'},
{'pclass': '1st', 'age': 2.0, 'sex': 'female'},
{'pclass': '1st', 'age': 30.0, 'sex': 'male'},
{'pclass': '1st', 'age': 25.0, 'sex': 'female'},
{'pclass': '1st', 'age': 0.9167, 'sex': 'male'}]
# 4.划分数据集
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y)
# 3.字典特征抽取
from sklearn.feature_extraction import DictVectorizer
transfer = DictVectorizer()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)
KNN算法对泰坦尼克号的生存进行预测
from sklearn.tree import DecisionTreeClassifier,export_graphviz
# 4.决策树预估器
estimator = DecisionTreeClassifier(criterion="entropy",max_depth=5)
estimator.fit(x_train,y_train)
# 5.模型评估
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)
y_predict:
[0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 0 1 0 0 0
0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0
0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0
1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 1]
直接对比真实值和预测值:
590 True
1157 True
641 False
398 True
853 True
...
563 True
358 True
121 True
1097 True
83 True
Name: survived, Length: 329, dtype: bool
准确率为:
0.790273556231003
KNN算法对泰坦尼克号的生存进行预测
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离
estimator = KNeighborsClassifier()
# 加入网格搜索和交叉验证
# 参数准备
params_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
# estimator:估计器对象 param_grid:估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
estimator = GridSearchCV(estimator, param_grid=params_dict, cv=10)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1:直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, 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_)
y_predict:
[0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0
0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
1 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0
0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 1
1 1 0 1 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 1 0
1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
0 1 0 1 0 0 0 1 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1 0 0 0
0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1]
y_test:
590 0
1157 0
641 1
398 1
853 0
..
563 0
358 1
121 0
1097 0
83 1
Name: survived, Length: 329, dtype: int64
直接对比真实值和预测值:
590 True
1157 True
641 False
398 True
853 True
...
563 True
358 True
121 True
1097 True
83 True
Name: survived, Length: 329, dtype: bool
准确率为:
0.7872340425531915
最佳参数
{'n_neighbors': 7}
最佳结果
0.8039270253555969
最佳估计器
KNeighborsClassifier(n_neighbors=7)
交叉验证结果
{'mean_fit_time': array([0.00149481, 0.00090151, 0.00109046, 0.0009779 , 0.00118496,
0.00090187]), 'std_fit_time': array([9.20082306e-04, 3.01925683e-04, 5.37038408e-04, 2.36335716e-05,
7.34021641e-04, 3.00797672e-04]), 'mean_score_time': array([0.00553658, 0.00467844, 0.00538712, 0.00519798, 0.00479972,
0.00488379]), 'std_score_time': array([0.00158095, 0.0009864 , 0.00118098, 0.00087649, 0.0004 ,
0.00103625]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
mask=[False, False, False, False, False, False],
fill_value='?',
dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([0.80808081, 0.82828283, 0.7979798 , 0.83838384, 0.81818182,
0.81818182]), 'split1_test_score': array([0.62626263, 0.56565657, 0.75757576, 0.75757576, 0.75757576,
0.76767677]), 'split2_test_score': array([0.62626263, 0.5959596 , 0.76767677, 0.75757576, 0.76767677,
0.76767677]), 'split3_test_score': array([0.55555556, 0.5959596 , 0.77777778, 0.7979798 , 0.80808081,
0.80808081]), 'split4_test_score': array([0.52040816, 0.52040816, 0.84693878, 0.84693878, 0.82653061,
0.79591837]), 'split5_test_score': array([0.6122449 , 0.60204082, 0.83673469, 0.83673469, 0.81632653,
0.79591837]), 'split6_test_score': array([0.62244898, 0.63265306, 0.85714286, 0.83673469, 0.84693878,
0.84693878]), 'split7_test_score': array([0.55102041, 0.55102041, 0.7755102 , 0.75510204, 0.75510204,
0.73469388]), 'split8_test_score': array([0.6122449 , 0.62244898, 0.76530612, 0.82653061, 0.79591837,
0.79591837]), 'split9_test_score': array([0.58163265, 0.58163265, 0.78571429, 0.78571429, 0.80612245,
0.79591837]), 'mean_test_score': array([0.61161616, 0.60960627, 0.7968357 , 0.80392703, 0.79984539,
0.79269223]), 'std_test_score': array([0.07428195, 0.07940273, 0.03473885, 0.03570535, 0.02912713,
0.02913109]), 'rank_test_score': array([5, 6, 3, 1, 2, 4])}
随机森林对泰坦尼克号的生存进行预测
from sklearn.ensemble import RandomForestClassifier
# 4.随机深林算法预估器
estimator = RandomForestClassifier()
# 加入网格搜索和交叉验证
# 参数准备
params_dict = {"n_estimators": [100, 200, 300, 400, 500, 1200],"max_depth":[4,5,6,7,8],"criterion":["entropy"]}
# estimator:估计器对象 param_grid:估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
estimator = GridSearchCV(estimator, param_grid=params_dict, cv=2)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1:直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2:计算准确率
score = estimator.score(x_test, 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_)
y_predict:
[0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0
0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0
0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0
1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1]
y_test:
590 0
1157 0
641 1
398 1
853 0
..
563 0
358 1
121 0
1097 0
83 1
Name: survived, Length: 329, dtype: int64
直接对比真实值和预测值:
590 True
1157 True
641 False
398 True
853 True
...
563 True
358 True
121 True
1097 True
83 True
Name: survived, Length: 329, dtype: bool
准确率为:
0.8145896656534954
最佳参数
{'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 300}
最佳结果
0.8241869918699187
最佳估计器
RandomForestClassifier(criterion='entropy', max_depth=5, n_estimators=300)
交叉验证结果
{'mean_fit_time': array([0.10773706, 0.19297969, 0.30615187, 0.3949554 , 0.49763954,
1.58897257, 0.1530757 , 0.3373847 , 0.42813838, 0.62685108,
1.13304913, 1.80858314, 0.13982916, 0.30716383, 0.46723175,
0.61357844, 0.76146626, 1.85352802, 0.15277028, 0.32195222,
0.47836339, 0.66029692, 1.33696401, 2.25642073, 0.19825661,
0.38971925, 0.65994167, 0.74528587, 1.19055343, 2.95836234]), 'std_fit_time': array([7.97224045e-03, 5.05089760e-04, 1.09999180e-02, 9.85383987e-04,
1.19386911e-02, 3.60212326e-02, 1.24795437e-02, 3.00669670e-03,
2.06164122e-02, 6.43358231e-02, 1.00861788e-02, 8.12751055e-02,
1.53231621e-03, 2.97200680e-03, 1.04892254e-02, 8.19456577e-03,
1.31447315e-02, 2.14662552e-02, 1.70080662e-02, 1.77611113e-02,
4.54127789e-03, 4.00140285e-02, 3.85288119e-01, 2.02952027e-01,
1.51988268e-02, 9.79542732e-03, 4.45888042e-02, 3.46029997e-02,
1.50036097e-01, 5.44578314e-01]), 'mean_score_time': array([0.01096785, 0.01993704, 0.03096426, 0.04036295, 0.05187905,
0.14403391, 0.01249444, 0.03091896, 0.03937757, 0.05281842,
0.0688498 , 0.18329692, 0.01442325, 0.0289228 , 0.04340398,
0.05485666, 0.06832874, 0.16604424, 0.01512146, 0.02568245,
0.04339993, 0.05734289, 0.09398592, 0.18908441, 0.01494157,
0.04238474, 0.05141592, 0.07779431, 0.0899986 , 0.17841971]), 'std_score_time': array([5.12599945e-06, 1.66893005e-05, 1.20401382e-05, 5.27977943e-04,
3.00967693e-03, 4.77623940e-03, 4.98890877e-04, 9.95516777e-04,
4.79340553e-04, 6.79492950e-06, 1.57356262e-05, 1.78389549e-02,
1.51050091e-03, 1.99365616e-03, 3.47173214e-03, 2.77757645e-05,
4.87208366e-04, 5.46932220e-04, 1.11722946e-03, 2.08139420e-04,
4.82201576e-04, 4.48501110e-03, 2.41731405e-02, 7.41183758e-03,
1.01578236e-03, 5.44941425e-03, 3.43656540e-03, 9.87052917e-04,
7.70485401e-03, 1.41978264e-04]), 'param_criterion': masked_array(data=['entropy', 'entropy', 'entropy', 'entropy', 'entropy',
'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
'entropy', 'entropy', 'entropy', 'entropy', 'entropy'],
mask=[False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False],
fill_value='?',
dtype=object), 'param_max_depth': masked_array(data=[4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8],
mask=[False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False],
fill_value='?',
dtype=object), 'param_n_estimators': masked_array(data=[100, 200, 300, 400, 500, 1200, 100, 200, 300, 400, 500,
1200, 100, 200, 300, 400, 500, 1200, 100, 200, 300,
400, 500, 1200, 100, 200, 300, 400, 500, 1200],
mask=[False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False],
fill_value='?',
dtype=object), 'params': [{'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 1200}], 'split0_test_score': array([0.81504065, 0.81504065, 0.81300813, 0.81300813, 0.81300813,
0.81300813, 0.80894309, 0.81504065, 0.81504065, 0.81504065,
0.81504065, 0.81707317, 0.80081301, 0.79674797, 0.79878049,
0.79878049, 0.79674797, 0.79674797, 0.79674797, 0.79471545,
0.79674797, 0.79471545, 0.79471545, 0.79674797, 0.79674797,
0.79471545, 0.79674797, 0.79674797, 0.79674797, 0.79674797]), 'split1_test_score': array([0.82723577, 0.82520325, 0.82520325, 0.82520325, 0.82520325,
0.82520325, 0.82723577, 0.82520325, 0.83333333, 0.83130081,
0.83333333, 0.82723577, 0.83536585, 0.83130081, 0.83130081,
0.82926829, 0.83536585, 0.82926829, 0.82520325, 0.82113821,
0.82723577, 0.82723577, 0.82723577, 0.82723577, 0.81910569,
0.82520325, 0.82317073, 0.82113821, 0.81910569, 0.81707317]), 'mean_test_score': array([0.82113821, 0.82012195, 0.81910569, 0.81910569, 0.81910569,
0.81910569, 0.81808943, 0.82012195, 0.82418699, 0.82317073,
0.82418699, 0.82215447, 0.81808943, 0.81402439, 0.81504065,
0.81402439, 0.81605691, 0.81300813, 0.81097561, 0.80792683,
0.81199187, 0.81097561, 0.81097561, 0.81199187, 0.80792683,
0.80995935, 0.80995935, 0.80894309, 0.80792683, 0.80691057]), 'std_test_score': array([0.00609756, 0.0050813 , 0.00609756, 0.00609756, 0.00609756,
0.00609756, 0.00914634, 0.0050813 , 0.00914634, 0.00813008,
0.00914634, 0.0050813 , 0.01727642, 0.01727642, 0.01626016,
0.0152439 , 0.01930894, 0.01626016, 0.01422764, 0.01321138,
0.0152439 , 0.01626016, 0.01626016, 0.0152439 , 0.01117886,
0.0152439 , 0.01321138, 0.01219512, 0.01117886, 0.0101626 ]), 'rank_test_score': array([ 5, 6, 8, 8, 8, 8, 12, 6, 1, 3, 1, 4, 12, 16, 15, 16, 14,
18, 21, 27, 19, 21, 21, 19, 27, 24, 24, 26, 27, 30])}
5 决策树总结
- 优点:
- 简单的理解和解释,树木可视化。
- 缺点:
- 决策树学习者可以创建不能很好地推广数据的过于复杂的树,这被称为过拟合。
- 改进:
- 减枝cart算法(决策树API当中已经实现,随机森林参数调优有相关介绍)
- 随机森林
注:企业重要决策,由于决策树很好的分析能力,在决策过程应用较多, 可以选择特征
5 集成学习方法之随机森林
1.随机森林的认识
- 什么是集成学习方法
集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型,各自独立地学习和作出预测。这些预测最后结合成组合预测,因此优于任何一个单分类的做出预测。
例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终投票结果就是True
- 什么是随机森林
在机器学习中,随机森林是一个包含多个决策树的分类器,并且其输出的类别是由个别树输出的类别的众数而定。
-
随机森林原理过程
学习算法根据下列算法而建造每棵树:
用N来表示训练用例(样本)的个数,M表示特征数目。
1、一次随机选出一个样本,重复N次, (有可能出现重复的样本)
2、随机去选出m个特征, m <<M,建立决策树
采取bootstrap抽样
-
为什么采用BootStrap抽样
为什么要随机抽样训练集?
如果不进行随机抽样,每棵树的训练集都一样,那么最终训练出的树分类结果也是完全一样的
为什么要有放回地抽样?
如果不是有放回的抽样,那么每棵树的训练样本都是不同的,都是没有交集的,这样每棵树都是“有偏的”,都是绝对“片面的”(当然这样说可能不对),也就是说每棵树训练出来都是有很大的差异的;而随机森林最后分类取决于多棵树(弱分类器)的投票表决。
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
.
- If “auto”, then
- bootstrap:boolean,optional(default = True)是否在构建树时使用放回抽样
- min_samples_split:节点划分最少样本数
- min_samples_leaf:叶子节点的最小样本数
-
超参数:n_estimator, max_depth, min_samples_split,min_samples_lea
# 随机森林去进行预测
rf = RandomForestClassifier()
param = {"n_estimators": [120,200,300,500,800,1200], "max_depth": [5, 8, 15, 25, 30]}
# 超参数调优
gc = GridSearchCV(rf, param_grid=param, cv=2)
gc.fit(x_train, y_train)
print("随机森林预测的准确率为:", gc.score(x_test, y_test))
3 总结
- 在当前所有算法中,具有极好的准确率
- 能够有效地运行在大数据集上,处理具有高维特征的输入样本,而且不需要降维
array([ 5, 6, 8, 8, 8, 8, 12, 6, 1, 3, 1, 4, 12, 16, 15, 16, 14,
18, 21, 27, 19, 21, 21, 19, 27, 24, 24, 26, 27, 30])}