机器学习基础3
分类算法
k近邻算法(KNN)
定义：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
计算距离公式：
两个样本的距离可以通过如下公式计算，又叫欧式距离。有a(a1,a2,a3),b(b1,b2,b3)则距离为
k近邻算法需要进行标准化
sklearn 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方法的值来决定最合适的算法。
(不同实现方式影响效率)
knn中一些函数及其参数
knn.fit()： 对训练集进行训练 它是最主要的函数。接收参数只有1个，就是训练数据集，每一行是一个样本，每一列是一个属性。它返回对象本身，即只是修改对象内部属性，因此直接调用就可以了，后面用该对象的预测函数取预测自然及用到了这个训练的结果。
knn.predict() 预测新输入的类别 接收输入的数组类型测试样本，一般是二维数组，每一行是一个样本，每一列是一个属性。返回数组类型的预测结果。
knn.score() 计算预测的准确率 接受参数有3个。输出为一个float型数，表示准确率。内部计算是按照predict()函数计算的结果记性计算的。 接收的3个参数： X: 接收输入的数组类型测试样本，一般是二维数组，每一行是一个样本，每一列是一个属性。 Y:这些预测样本的真实标签，一维数组或者二维数组。 sample_weight=None：是一个和X一样长的数组，表示各样本对准确率影响的权重，一般默认为None.
k-近邻算法优缺点
优点：
简单，易于理解，易于实现，无需估计参数，无需训练。
缺点：
懒惰算法，对测试样本分类时的计算量大，内存开销大必须指定K值，K值选择不当则分类精度不能保证。
使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试 。
鸢尾花knn分类示例：
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
def knncls():
"""
K-近邻预测鸢尾花
:return:None
"""
# 读取数据
li = load_iris()
print(li)
# 进行数据的分割训练集合测试集
# 特征值和目标值
x = li.data
y = li.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 特征工程（标准化）
std = StandardScaler()
# 对训练集和测试集的特征值进行标准化
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)
# 进行算法流程
knn = KNeighborsClassifier()
knn.fit(x_train, y_train)
# 得出预测结果
predict = knn.predict(x_test)
print("预测的目标标签为：", predict)
# 得出准确率
print("预测的准确率:", knn.score(x_test, y_test))
return None
if __name__ == "__main__":
knncls()
输出结果：
{'data': array([[5.1, 3.5, 1.4, 0.2],
[4.9, 3. , 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
[5. , 3.6, 1.4, 0.2],
[5.4, 3.9, 1.7, 0.4],
[4.6, 3.4, 1.4, 0.3],
[5. , 3.4, 1.5, 0.2],
[4.4, 2.9, 1.4, 0.2],
[4.9, 3.1, 1.5, 0.1],
[5.4, 3.7, 1.5, 0.2],
[4.8, 3.4, 1.6, 0.2],
...
[5.9, 3. , 5.1, 1.8]]),
'target': array
([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]),
'target_names': array(['setosa', 'versicolor', 'virginica'], dtype='<U10')
......
预测的目标签到位置为：
[2 0 2 0 2 2 2 2 1 1 0 0 2 0 1 2 0 2 0 0 1 0 1 2 0 2 1 0 0 0 1 1 0 0 1 2 0 1]
预测的准确率: 1.0
朴素贝叶斯算法
联合概率和条件概率
联合概率：包含多个条件，且所有条件同时成立的概率
记作：𝑃(𝐴, 𝐵)
条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
记作：𝑃(𝐴 | 𝐵)
特性：当A1 A2独立时：P(A1, A2 | B) = P(A1 | B)P(A2 | B)
朴素贝叶斯-贝叶斯公式
拉普拉斯平滑
如果词频列表里面有很多出现次数都为0，很可能计算结果都为零
解决方法：拉普拉斯平滑系数
𝑃(𝐹1│𝐶)=(𝑁𝑖 + 𝛼) / (𝑁 + 𝛼𝑚)
𝛼为指定的系数一般为1，m为训练文档中统计出的特征词类数
sklearn朴素贝叶斯实现API
sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
alpha：拉普拉斯平滑系数
示例
# sklearn20类新闻分类 20个新闻组数据集包含20个主题的18000个新闻组帖子
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfVectorizer
def naviebayes():
"""
朴素贝叶斯
:return:None
"""
news = fetch_20newsgroups(subset='all')
#进行数据分割
x_train, x_test, y_train, y_test =
train_test_split(news.data,news.target,test_size=0.25)
tf = TfidfVectorizer()
#以训练集种的词的列表进行重要性统计
x_train=tf.fit_transform(x_train)
x_test=tf.transform(x_test)
# 进行朴素贝叶斯算法
mlt=MultinomialNB(alpha=1.0)
print(x_train)
print()
mlt.fit(x_train,y_train)
print("预测的文章类别为",mlt.predict(x_test))
#得出准确率
print("准确率为",mlt.score(x_test,y_test))
if __name__ == "__main__":
naviebayes()
输出结果：
(0, 118933) 0.0345169949907417
(0, 108574) 0.02756660153115229
(0, 65159) 0.06791162660486898
(0, 67557) 0.07619782099613641
(0, 7647) 0.03209913885420742
.....
预测的文章类别为 [10 3 4 ... 13 7 11]
准确率为 0.8404074702886248
朴素贝叶斯优缺点
优点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
对缺失数据不太敏感，算法也比较简单，常用于文本分类。
分类准确度高，速度快 不需要调参
缺点：
需要知道先验概率P(F1, F2,… | C)，因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。
分类模型的评估
- 一般最常见使用的是准确率，即预测结果正确的百分比
estimator.score()
- 混淆矩阵
在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵(适用于多分类)
以真假分类为例 如果有n个目标值 则会有n个混淆矩阵
精准率和召回率
精确率：预测结果为正例样本中真实为正例的比例（查得准）
召回率：真实为正例的样本中预测结果为正例的比例（查的全，对正样本的区分能力）
其他分类标准，F1-score，反映了模型的稳健型
分类模型评估API
sklearn.metrics.classification_report
sklearn.metrics.classification_report(y_true, y_pred, target_names=None)
y_true：真实目标值 即y_test
y_pred：估计器预测目标值
target_names：目标类别名称
return：每个类别精确率与召回率
模型选择和调优
交叉验证
为了让被评估的模型更加准确可信
交叉验证过程
交叉验证：将拿到的数据，分为训练集和验证集。
以下图为例：将数据分
成5份，其中一份作为验证集。然后经过5次(组)的测试，每次都更换不同
的验证集。即得到5组模型的结果，取平均值作为最终结果。又称5折交叉
验证。
超参数搜索-网格搜索
超参数搜索-网格搜索
通常情况下，有很多参数是需要手动指定的（如k-近邻算法中的K值），
这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组
合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建
立模型。
超参数搜索-网格搜索API
sklearn.model_selection.GridSearchCV
sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
对估计器的指定参数值进行详尽搜索
estimator：估计器对象
param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}
cv：指定几折交叉验证
fit：输入训练数据
score：准确率
结果分析：
best_score_:在交叉验证中测试的最好结果
best_estimator_：最好的参数模型
cv_results_:每次交叉验证后的测试集准确率结果和训练集准确率结果
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
def knncls():
"""
K-近邻预测鸢尾花
:return:None
"""
# 读取数据
li = load_iris()
print(li)
# 进行数据的分割训练集合测试集
# 特征值和目标值
x = li.data
y = li.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 特征工程（标准化）
std = StandardScaler()
# 对训练集和测试集的特征值进行标准化
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)
# 进行算法流程
knn = KNeighborsClassifier() # 此处不可以设置参数
# 构造一些参数值进行搜索
param={"n_neighbors":[3,5,10]}
gc = GridSearchCV(knn,param_grid=param,cv=2)
gc.fit(x_train,y_train)
#预测准确率
print("在测试集上的准确率：", gc.score(x_test,y_test))
#交叉验证在训练集
print("在交叉验证中最好的结果：",gc.best_score_)
print("在交叉验证中最好的模型：",gc.best_estimator_)
print("每个超参数每次交叉验证结果：", gc.cv_results_)
return None
if __name__ == "__main__":
knncls()
输出结果：
E:\anaconda\python.exe E:/pythontest/test/e.py
{'data': array([[5.1, 3.5, 1.4, 0.2],
[4.9, 3. , 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
[5. , 3.6, 1.4, 0.2],
[5.4, 3.9, 1.7, 0.4],
[4.6, 3.4, 1.4, 0.3],
....
[5.9, 3. , 5.1, 1.8]]), 'target': array
([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]),
'target_names': array(['setosa', 'versicolor', 'virginica'], dtype='<U10'), ...
在测试集上的准确率： 0.9736842105263158
在交叉验证中最好的结果： 0.9375
在交叉验证中最好的模型： KNeighborsClassifier(
algorithm='auto', leaf_size=30, metric='minkowski',
metric_params=None, n_jobs=None, n_neighbors=5, p=2,
weights='uniform')
每个超参数每次交叉验证结果：
{'mean_fit_time': array([0.00049865, 0.00099742, 0. ]), 'std_fit_time': array([4.98652458e-04, 3.57627869e-07, 0.00000000e+00]), 'mean_score_time': array([0.00249326, 0.0009973 , 0.00199544]), 'std_score_time': array([4.98890877e-04, 2.38418579e-07, 5.96046448e-07]), 'param_n_neighbors': masked_array(data=[3, 5, 10],
mask=[False, False, False],fill_value='?', dtype=object), 'params': [{'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 10}], 'split0_test_score': array([0.91071429, 0.92857143, 0.92857143]), 'split1_test_score': array([0.89285714, 0.94642857, 0.91071429]), 'mean_test_score': array([0.90178571, 0.9375 , 0.91964286]), 'std_test_score': array([0.00892857, 0.00892857, 0.00892857]), 'rank_test_score': array([3, 1, 2])}
决策树
决策树思想的来源非常朴素，程序设计中的条件分支结构就是if - then结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法
决策树的划分依据之一 ——信息增益
特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差，
即公式为：g(D, A)=H(D)-H(D|A）
注：信息增益表示得知特征X的信息而使得类Y的信息的不确定性减少的程度，值越大，不确定性减少程度大
常见决策树使用的算法
ID3：信息增益 最大的准则
C4.5：信息增益比 最大的准则
CART ：
回归树: 平方误差 最小
分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的原则
sklearn决策树API
class sklearn.tree.DecisionTreeClassifier(
criterion=’gini’, max_depth=None,random_state=None)
决策树分类器
criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’
max_depth:树的深度大小
random_state:随机数种子
method:
decision_path:返回决策树的路径
sklearn.tree.export_graphviz() 该函数能够导出DOT格式文件
tree.export_graphviz(estimator,out_file='tree.dot’,feature_names=[‘’,’’])
决策树对泰坦尼克号进行预测生死示例
Titanic_data.csv
链接：https://pan.baidu.com/s/13QlxxWvAv82dHOqKHPfQog 提取码：1234
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import export_graphviz
import pandas as pd
def decision():
"""
决策树对泰坦尼克号进行预测生死
:return: None
"""
titan_data = pd.read_csv(r'C:\Users\cpx\Desktop\Titanic_data.csv')
x = titan_data[['Pclass', 'Age', 'Sex']]
y = titan_data['Survived']
# 缺失值处理
x['Age'].fillna(x['Age'].mean(), inplace=True)
# 分割数据成训练集和测试集
x_train,x_test,y_train,y_test=train_test_split(x,y, test_size=0.25)
# 进行特征工程 变成one-hot编码
dict = DictVectorizer(sparse=False)
x_train = dict.fit_transform(x_train.to_dict(orient='records'))
print(dict.get_feature_names())
x_test = dict.transform(x_test.to_dict(orient='records'))
print(x_train)
# 决策树进行预测
dec = DecisionTreeClassifier(max_depth=5)
dec.fit(x_train,y_train)
# 预测准确率
print("准确率为",dec.score(x_test,y_test))
# 导出决策树结构
export_graphviz(dec, out_file="./tree.dot", feature_names=['年龄', '层',
'女性', '男性'])
#要对应feature_names的原始名'Age', 'Pclass', 'Sex=female', 'Sex=male'
return None
if __name__ == "__main__":
decision()
输出结果
['Age', 'Pclass', 'Sex=female', 'Sex=male']
[[45. 3. 0. 1. ]
[18. 2. 0. 1. ]
[29.88113767 3. 0. 1. ]
...
[48. 1. 1. 0. ]
[ 0.75 3. 1. 0. ]
[23. 3. 0. 1. ]]
准确率为 0.8536585365853658
graphviz能够将dot文件转换为pdf、png
决策树的优缺点
优点：
简单的理解和解释，树木可视化。
需要很少的数据准备，其他技术通常需要数据归一化，
缺点：
决策树学习者可以创建不能很好地推广数据的过于复杂的树，
这被称为过拟合。
决策树可能不稳定，因为数据的小变化可能会导致完全不同的树
被生成
改进：
减枝cart算法
随机森林
随机森林
集成学习：
通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成单预测，因此优于任何一个单分类的做出预测。
随机森林：
在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。
例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终结果会是True.
随机森林建立多个决策树的过程：
- 用N来表示训练用例（样本）的个数，M表示总特征数目。
- 输入特征数目m，用于确定决策树上一个节点的决策结果；其中m应远小于M。
- 随机从N个训练用例（样本）中以有放回抽样的方式，取样N次，形成一个训练集（即bootstrap取样），并用未抽到的用例（样本）作预测，评估其误差。
为什么要随机抽样训练集？
如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
为什么要有放回地抽样？
如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。
集成学习API
class sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=’gini’,
max_depth=None, bootstrap=True, random_state=None)
随机森林分类器
n_estimators：integer，optional（default = 10） 森林里的树木数量
criteria：string，可选（default =“gini”）分割特征的测量方法
max_depth：integer或None，可选（默认=无）树的最大深度
bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样
max_feature='auto' 每个决策树中最大特种数量
='sqrt' max_feature=sqr(n_features) n_features总共特征数
='log2' max_feature=log2(n_features)
随机森林的优点：
在当前所有算法中，具有极好的准确率
能够有效地运行在大数据集上
能够处理具有高维特征的输入样本，而且不需要降维
能够评估各个特征在分类问题上的重要性
对于缺省值问题也能够获得很好得结果
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
def decision():
"""
决策树对泰坦尼克号进行预测生死
:return: None
"""
titan_data = pd.read_csv(r'C:\Users\cpx\Desktop\Titanic_data.csv')
x = titan_data[['Pclass', 'Age', 'Sex']]
y = titan_data['Survived']
# 缺失值处理
x['Age'].fillna(x['Age'].mean(), inplace=True)
# 分割数据成训练集和测试集
x_train,x_test,y_train,y_test=train_test_split(x,y, test_size=0.25)
# 进行特征工程 变成one-hot编码
dict = DictVectorizer(sparse=False)
x_train = dict.fit_transform(x_train.to_dict(orient='records'))
print(dict.get_feature_names())
x_test = dict.transform(x_test.to_dict(orient='records'))
print(x_train)
# 随机森林 超参数调优
rf = RandomForestClassifier()
# 网格搜索与交叉验证
param = {"n_estimators": [120,200,300,500,800,1200],"max_depth": [5,8,15,25,30]}
# 6*5=30次搜索
gc = GridSearchCV(rf,param_grid=param, cv=2)
gc.fit(x_train, y_train)
print("准确率为", gc.score(x_test, y_test))
print("查看选择模型", gc.best_params_)
return None
if __name__ == "__main__":
decision()
输出结果：
['Age', 'Pclass', 'Sex=female', 'Sex=male']
[[30. 3. 0. 1. ]
[47. 1. 0. 1. ]
[29.88113767 3. 0. 1. ]
...
[27. 2. 0. 1. ]
[15. 3. 0. 1. ]
[28. 1. 0. 1. ]]
准确率为 0.8628048780487805
查看选择模型 {'max_depth': 5, 'n_estimators': 120}
随机森林优点
在当前所有算法中，具有极好的准确率
能够有效地运行在大数据集上
能够处理具有高维特征的输入样本，而且不需要降维
能够评估各个特征在分类问题上的重要性
对于缺省值问题也能够获得很好得结果
扫一扫
6616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
