数据挖掘的11大算法及python实现（个人笔记整理，非教学用）_使用python进行数据分析挖掘的算法实现

分类算法：C4.5，朴素贝叶斯（Naive Bayes），SVM，KNN，Adaboost，CARTl 。聚类算法：K-Means，EMl 。关联分析：Aprioril 。连接分析：PageRank

---

准备数据

我们统一用鸢尾花作为测试数据以便能对比各个算法的性能。

国际权威的学术组织 ICDM （the IEEE International Conference on Data Mining）评选出了十大经典的算法。按照不同的目的，我可以将这些算法分成四类。

---

分类算法：C4.5（ID3），朴素贝叶斯（Naive Bayes），SVM，KNN，Adaboost，CARTl ,randomForest,bugging
聚类算法：K-Means，EMl
关联分析：Aprioril
连接分析：PageRank

一、C4.5 算法

C4.5 是决策树的算法，它创造性地在决策树构造过程中就进行了剪枝，并且可以处理连续的属性，也能对不完整的数据进行处理。它可以说是决策树分类中，具有里程碑式意义的算法。
信息熵（entropy）的概念，它表示了信息的不确定度.

ID3 算法计算的是信息增益，信息增益指的就是划分可以带来纯度的提高，信息熵的下降。它的计算公式，是父亲节点的信息熵减去所有子节点的信息熵。在计算的过程中，我们会计算每个子节点的归一化信息熵，即按照每个子节点在父节点中出现的概率，来计算这些子节点的信息熵。所以信息增益的公式可以表示为：

公式中 D 是父亲节点，Di 是子节点，Gain(D,a) 中的 a 作为 D 节点的属性选择。
ID3 就是要将信息增益最大的节点作为父节点，这样可以得到纯度高的决策树，所以我们将信息增益最大的节点作为根节点。ID3 的算法规则相对简单，可解释性强。同样也存在缺陷，比如我们会发现 ID3 算法倾向于选择取值比较多的属性。
ID3 有一个缺陷就是，有些属性可能对分类任务没有太大作用，但是他们仍然可能会被选为最优属性。
C4.5 都在哪些方面改进了 ID3 呢？
C4.5 采用信息增益率的方式来选择属性。信息增益率 = 信息增益 / 属性熵。
ID3 构造决策树的时候，容易产生过拟合的情况。在 C4.5 中，会在决策树构造之后采用悲观剪枝（PEP），这样可以提升决策树的泛化能力。悲观剪枝是后剪枝技术中的一种，通过递归估算每个内部节点的分类错误率，比较剪枝前后这个节点的分类错误率来决定是否对其进行剪枝。这种剪枝方法不再需要一个单独的测试数据集。
针对数据集不完整的情况，C4.5 也可以进行处理。
C4.5 需要对数据集进行多次扫描，算法效率相对较低。
代码：

from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X,y = load_iris(return_X_y=True)
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
clf = tree.DecisionTreeClassifier(criterion="entropy")
clf = clf.fit(train_X,train_y)
print(clf.score(test_X,test_y))
1
2
3
4
5
6
7
8
9

准确率：96%

二、CART 算法

当基尼系数越小的时候，说明样本之间的差异性小，不确定程度低。分类的过程本身是一个不确定度降低的过程，即纯度的提升过程。所以 CART 算法在构造分类树的时候，会选择基尼系数最小的属性作为属性的划分。

GINI 系数的计算公式：

节点 D 的基尼系数等于子节点 D1 和 D2 的归一化基尼系数之和，用公式表示为：

from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X,y = load_iris(return_X_y=True)
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
clf = tree.DecisionTreeClassifier(criterion="gini")
clf = clf.fit(train_X,train_y)
print(clf.score(test_X,test_y))
1
2
3
4
5
6
7
8
9

准确率：96%

三、SVM 算法

SVM 的中文叫支持向量机，英文是 Support Vector Machine，简称 SVM。SVM 在训练中建立了一个超平面的分类模型。
能存在多个最优决策面，它们都能把数据集正确分开，这些最优决策面的分类间隔可能是不同的，而那个拥有“最大间隔”（max margin）的决策面就是 SVM 要找的最优解。
非线性 SVM 中，核函数的选择就是影响 SVM 最大的变量。最常用的核函数有线性核、多项式核、高斯核、拉普拉斯核、sigmoid 核，或者是这些核函数的组合。这些函数的区别在于映射方式的不同。通过这些核函数，我们就可以把样本空间投射到新的高维空间中。
SVM 最主要的思想就是硬间隔、软间隔和核函数.
kernel 代表核函数的选择，它有四种选择，只不过默认是 rbf，即高斯核函数。
linear：线性核函数
poly：多项式核函数
rbf：高斯核函数（默认）
sigmoid：sigmoid 核函数这四种函数代表不同的映射方式，如何选择这 4 种核函数呢？
线性核函数，是在数据线性可分的情况下使用的，运算速度快，效果好。不足在于它不能处理线性不可分的数据。
多项式核函数可以将数据从低维空间映射到高维空间，但参数比较多，计算量大。
高斯核函数同样可以将样本映射到高维空间，但相比于多项式核函数来说所需的参数比较少，通常性能不错，所以是默认使用的核函数。
了解深度学习的同学应该知道 sigmoid 经常用在神经网络的映射中。因此当选用 sigmoid 核函数时，SVM 实现的是多层神经网络。

from sklearn import svm
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X,y = load_iris(return_X_y=True)

train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = svm.SVC(kernel='rbf')
clf = clf.fit(train_X,train_y)
print(clf.score(test_X,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

准确率96%。

四、KNN算法

KNN 也叫 K 最近邻算法，英文是 K-Nearest Neighbor。所谓 K 近邻，就是每个样本都可以用它最接近的 K 个邻居来代表。如果一个样本，它的 K 个最接近的邻居都属于分类 A，那么这个样本也属于分类 A。
KNN 的工作原理。整个计算过程分为三步：
计算待分类物体与其他物体之间的距离；
统计距离最近的 K 个邻居；
对于 K 个最近的邻居，它们属于哪个分类最多，待分类物体就属于哪一类。
交叉验证的思路就是，把样本集中的大部分样本作为训练集，剩余的小部分样本用于预测，来验证分类模型的准确性。所以在 KNN 算法中，我们一般会把 K 值选取在较小的范围内，同时在验证集上准确率最高的那一个最终确定作为 K 值。
KNN算法是机器学习中最简单的算法之一，但是工程实现上，如果训练样本过大，则传统的遍历全样本寻找k近邻的方式将导致性能的急剧下降。 因此，为了优化效率，不同的训练数据存储结构被纳入到实现方式之中。在sikit-learn中的KNN算法参数也提供了’kd_tree’之类的算法选择项。
n_neighbors：默认为5，就是k-NN的k的值，选取最近的k个点。
weights：默认是uniform，参数可以是uniform、distance

from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X,y = load_iris(return_X_y=True)

train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = KNeighborsClassifier(n_neighbors=5,algorithm='kd_tree',weights='uniform')
clf = clf.fit(train_X,train_y)
print(clf.score(test_X,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

五、AdaBoost算法

Adaboost 在训练中建立了一个联合的分类模型。boost 在英文中代表提升的意思，所以 Adaboost 是个构建分类器的提升算法。它可以让我们多个弱的分类器组成一个强的分类器，所以 Adaboost 也是一个常用的分类算法。
算法通过训练多个弱分类器，将它们组合成一个强分类器，也就是我们俗话说的“三个臭皮匠，顶个诸葛亮”。

假设弱分类器为 Gi​(x)，它在强分类器中的权重 αi​，那么就可以得出强分类器 f(x)：

如果弱分类器的分类效果好，那么权重应该比较大，如果弱分类器的分类效果一般，权重应该降低。所以我们需要基于这个弱分类器对样本的分类错误率来决定它的权重，用公式表示就是：

其中 ei​ 代表第 i 个分类器的分类错误率。
AdaBoost 算法是通过改变样本的数据分布来实现的。AdaBoost 会判断每次训练的样本是否正确分类，对于正确分类的样本，降低它的权重，对于被错误分类的样本，增加它的权重。再基于上一次得到的分类准确率，来确定这次训练样本中每个样本的权重。然后将修改过权重的新数据集传递给下一层的分类器进行训练。这样做的好处就是，通过每一轮训练样本的动态权重，可以让训练的焦点集中到难分类的样本上，最终得到的弱分类器的组合更容易得到更高的分类准确率。

n_estimators：算法的最大迭代次数，也是分类器的个数，每一次迭代都会引入一个新的弱分类器来增加原有的分类器的组合能力。默认是 50。

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import *

X,y = load_iris(return_X_y=True)
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(),n_estimators=50)
clf = clf.fit(train_X,train_y)
pre_y = clf.predict(test_X)
for i,j in zip(pre_y,test_y):
    print(i,j)
print('%.4lf'%accuracy_score(pre_y,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

准确率：96%。
AdaBoost是串行的多个弱分类器组合，还有一类是并行的弱分类器组合，叫Bagging，代表是随机森林。

六、Apriori算法

Apriori 是一种挖掘关联规则（association rules）的算法，它通过挖掘频繁项集（frequent item sets）来揭示物品之间的关联关系，被广泛应用到商业挖掘和网络安全等领域中。频繁项集是指经常出现在一起的物品的集合，关联规则暗示着两种物品之间可能存在很强的关系。
Apriori 算法其实就是查找频繁项集 (frequent itemset) 的过程。频繁项集就是支持度大于等于最小支持度 (Min Support) 阈值的项集，所以小于最小值支持度的项目就是非频繁项集，算法进行删除，而大于等于最小支持度的项集就是频繁项集，然后做进一步划分。
Apriori 在计算的过程中有以下几个缺点：可能产生大量的候选集。因为采用排列组合的方式，把可能的项集都组合出来了；每次计算都需要重新扫描数据集，来计算每个项集的支持度。
所以 Apriori 算法会浪费很多计算空间和计算时间，为此人们提出了 FP-Growth 算法，它的特点是：创建了一棵 FP 树来存储频繁项集。在创建前对不满足最小支持度的项进行删除，减少了存储空间。整个生成过程只遍历数据集 2 次，大大减少了计算量。所以在实际工作中，我们常用 FP-Growth 来做频繁项集的挖掘，下面我给你简述下 FP-Growth 的原理。
FP就是根据结果出现的频繁数进行构建的，构建过程如下问：FP-Growth

from efficient_apriori import apriori

data = [['牛奶','面包','尿布'], ['可乐','面包', '尿布', '啤酒'],
        ['牛奶','尿布', '啤酒', '鸡蛋'], ['面包', '牛奶', '尿布',
        '啤酒'], ['面包', '牛奶', '尿布', '可乐']]

itemsets ,rules = apriori(data,min_support=0.5,min_confidence=1)
print(itemsets)
print(rules)
1
2
3
4
5
6
7
8
9

输出有关联度的列表：

[{牛奶} -> {尿布}, {面包} -> {尿布}, {啤酒} -> {尿布}, {牛奶, 面包} -> {尿布}]
1

七、K-Means算法

K-Means 算法是一个聚类算法。想把物体划分成 K 类。假设每个类别里面，都有个“中心点”，它是这个类别的核心。现在有一个新点要归类，这时候就只要计算这个新点与 K 个中心点的距离，距离哪个中心点近，就变成了哪个类别。
K-Means是无监督学习，随机指定质心，然后迭代更新质心位置，知道所有点不在发生划分改变为止。

from sklearn.preprocessing import StandardScaler
from sklearn.metrics import *

X,y = load_iris(return_X_y=True)

train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = KMeans(n_clusters=3,max_iter=300)
clf = clf.fit(train_X,train_y)
pre_y = clf.predict(test_X)
# for i,j in zip(pre_y,test_y):
#     print(i,j)
print('%.4lf'%accuracy_score(pre_y,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

八、朴素贝叶斯（Naive Bayes）算法

算法原理：利用贝叶斯公式计算特征的概率，也就是利用先验概率和后验概率的结合，概率大的作为分类结果。
贝叶斯公式：

换个表达形式就会明朗很多，如下：

我们最终求得p(类别|特征)即可！而又可以转化为利用已经有的数据，计算后验概率和先验概率。也就是已经有的测试数据样本的统计信息，便可以得到p(类别|特征)的值。详解

sklearn 机器学习包sklearn 的全称叫 Scikit-learn，它给我们提供了 3 个朴素贝叶斯分类算法，分别是高斯朴素贝叶斯（GaussianNB）、多项式朴素贝叶斯（MultinomialNB）和伯努利朴素贝叶斯（BernoulliNB）。这三种算法适合应用在不同的场景下，我们应该根据特征变量的不同选择不同的算法：
高斯朴素贝叶斯：特征变量是连续变量，符合高斯分布，比如说人的身高，物体的长度。
多项式朴素贝叶斯：特征变量是离散变量，符合多项分布，在文档分类中特征变量体现在一个单词出现的次数，或者是单词的 TF-IDF 值等。
伯努利朴素贝叶斯：特征变量是布尔变量，符合 0/1 分布，在文档分类中特征是单词是否出现。

朴素贝叶斯模型是基于概率论的原理，它的思想是这样的：对于给出的未知物体想要进行分类，就需要求解在这个未知物体出现的条件下各个类别出现的概率，哪个最大，就认为这个未知物体属于哪个分类。
贝叶斯原理、贝叶斯分类和朴素贝叶斯这三者之间是有区别：贝叶斯原理是最大的概念，它解决了概率论中“逆向概率”的问题，在这个理论基础上，人们设计出了贝叶斯分类器，朴素贝叶斯分类是贝叶斯分类器中的一种，也是最简单，最常用的分类器。
朴素贝叶斯之所以朴素是因为它假设属性是相互独立的，因此对实际情况有所约束，如果属性之间存在关联，分类准确率会降低。不过好在对于大部分情况下，朴素贝叶斯的分类效果都不错。
朴素贝叶斯分类常用于文本分类，尤其是对于英文等语言来说，分类效果很好。它常用于垃圾文本过滤、情感预测、推荐系统等。

from sklearn.naive_bayes import MultinomialNB
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X,y = load_iris(return_X_y=True)
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
clf = MultinomialNB(alpha=0.001)
clf = clf.fit(train_X,train_y)
print(clf.score(test_X,test_y))
1
2
3
4
5
6
7
8
9

准确率70%。用的是多项式贝叶斯。
如果用高斯贝叶斯:

from sklearn.naive_bayes import MultinomialNB,GaussianNB
clf = GaussianNB()
1
2

准确率96%。

九、EM算法

EM 的英文是 Expectation Maximization，所以 EM 算法也叫最大期望算法。，是求参数的最大似然估计的一种方法。
原理是这样的：假设我们想要评估参数 A 和参数 B，在开始状态下二者都是未知的，并且知道了 A 的信息就可以得到 B 的信息，反过来知道了 B 也就得到了 A。可以考虑首先赋予 A 某个初值，以此得到 B 的估值，然后从 B 的估值出发，重新估计 A 的取值，这个过程一直持续到收敛为止。EM 算法经常用于聚类和机器学习领域中。

首先，随机选取 PA=正面 PB =正面 的初始值。EM算法的E步骤，是计算在当前的预估参数下，隐含变量（是A硬币还是B硬币）的每个值出现的概率，取最大概率的那个座位本次实验是A还是B。

from sklearn.mixture import GaussianMixture
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import *

X,y = load_iris(return_X_y=True)

train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = GaussianMixture(n_components=3)
clf = clf.fit(train_X,train_y)
pre_y = clf.predict(test_X)
# for i,j in zip(pre_y,test_y):
#     print(i,j)
print('%.4lf'%accuracy_score(pre_y,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

十、PageRank算法

PageRank 起源于论文影响力的计算方式，如果一篇文论被引入的次数越多，就代表这篇论文的影响力越强。同样 PageRank 被 Google 创造性地应用到了网页权重的计算中：当一个页面链出的页面越多，说明这个页面的“参考文献”越多，当这个页面被链入的频率越高，说明这个页面被引用的次数越高。基于这个原理，我们可以得到网站的权重划分。
假设一共有 4 个网页 A、B、C、D。它们之间的链接信息如图所示：

一个网页的影响力 = 所有入链集合的页面的加权影响力之和，用公式表示为：

例子中，你能看到 A 有三个出链分别链接到了 B、C、D 上。那么当用户访问 A 的时候，就有跳转到 B、C 或者 D 的可能性，跳转概率均为 1/3。B 有两个出链，链接到了 A 和 D 上，跳转概率为 1/2。这样，我们可以得到 A、B、C、D 这四个网页的转移矩阵 M：

假设 A、B、C、D 四个页面的初始影响力都是相同的，即：
当进行第一次转移之后，各页面的影响力 w1​ 变为：

然后我们再用转移矩阵乘以 w1​ 得到 w2​ 结果，直到第 n 次迭代后 wn​ 影响力不再发生变化，可以收敛到 (0.3333，0.2222，0.2222，0.2222），也就是对应着 A、B、C、D 四个页面最终平衡状态下的影响力。
A 页面相比于其他页面来说权重更大，也就是 PR 值更高。而 B、C、D 页面的 PR 值相等。

import networkx as nx
# 创建有向图
G = nx.DiGraph()
# 有向图之间边的关系
edges = [("A", "B"), ("A", "C"), ("A", "D"), ("B", "A"), ("B", "D"), ("C", "A"), ("D", "B"), ("D", "C")]
for edge in edges:
    G.add_edge(edge[0], edge[1])
pagerank_list = nx.pagerank(G, alpha=1)
print("pagerank值是：", pagerank_list)
1
2
3
4
5
6
7
8
9
10

结果：

pagerank值是： {'A': 0.33333396911621094, 'B': 0.22222201029459634, 'C': 0.22222201029459634, 'D': 0.22222201029459634}
1

十一、随机森林（Random Forest）算法

随机森林就是通过集成学习的思想：将多棵树并行集成的一种算法，它的基本单元是决策树，而它的本质属于机器学习的一大分支——集成学习（Ensemble Learning）方法。
随机森林的名称中有两个关键词，一个是“随机”，一个就是“森林”。“森林”我们很好理解，一棵叫做树，那么成百上千棵就可以叫做森林了，这样的比喻还是很贴切的，其实这也是随机森林的主要思想–集成思想的体现。
“随机”的含义是：如果训练集大小为N，对于每棵树而言，随机且有放回地从训练集中的抽取N个训练样本（这种采样方式称为bootstrap sample方法），作为该树的训练集。详解

from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import *

X,y = load_iris(return_X_y=True)
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=0.33,random_state=0)
# 采用Z-Score规范化数据，保证每个特征维度的数据均值为0，方差为1
ss = StandardScaler()
train_X = ss.fit_transform(train_X)
test_X = ss.transform(test_X)
clf = RandomForestClassifier(n_jobs=-1)
clf = clf.fit(train_X,train_y)
pre_y = clf.predict(test_X)
# for i,j in zip(pre_y,test_y):
#     print(i,j)
print('%.4lf'%accuracy_score(pre_y,test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

总结

了解基本算法原理，尽管我们亲自实现算法的可能性不大，了解算法还是挺有用。