搞数仓也得懂几个常用机器学习算法

01回归算法

一、理解线性回归模型

首先讲回归模型，回归模型研究的是因变量（目标）和自变量（预测器）之间的关系，因变量可以是连续也可以离散，如果是离散的就是分类问题。思考房价预测模型，我们可以根据房子的大小、户型、位置、南北通透等自变量预测出房子的售价，这是最简单的回归模型，在初中里面回归表达式一般这样写，其中x是自变量，y是因变量，w是特征矩阵，b是偏置。

在机器学习推导里面引入线性代数的思想，将假设我们用一个表达式来描述放假预测模型，x代表一个房子的特征集，它是一个n×1的列向量，总共有m个特征集，θ是一个n×1的列向量，是我们想要求得未知数。

我们采用误差最小的策略，比如有预测表达式：y工资=Θ1*学历+Θ2*工作经验+Θ3*技术能力+.......+Θn*x+基本工资，预测的y值和实际值y_存有差距，策略函数就是使得m个特征集的（真实值y-预测值）的平方和最小。（差值可能是负数，所以采用平方和）；

按照对于正规方程的求法，我们对θ 求偏导：

也就是，给定特征矩阵X和因变量y，即可以求使误差率最小的θ值，满足后续的回归模型。了解线性代数的童靴可以看出来问题，在θ的表达式中有求逆运算，需要保证矩阵可逆，这一般是无法保证的，这样就会造成θ无解，策略失效；

二、计算机的做法：梯度下降

常规的方程需要大量的矩阵运算，尤其是矩阵的逆运算，在矩阵很大的情况下，会大大增加计算复杂性。，且正规方程法对矩阵求偏导有一定的局限性（无法保证矩阵可逆），下面介绍梯度下降法，也就是计算机的解决方法，每次走一小步，保证这一小步是最有效的一步，可以想象自己正在下山，你不知道目的地（全局最小值）在哪，但是你能够保证自己每次走的都是最陡峭的一步；

我们的策略仍然保持不变，就是使得m个特征集的（真实值y-预测值）的平方和最小：

梯度下降法实现：赋予初始θ 值，并根据公式逐步更新θ 使得J(θ) 不断减少，最终至收敛，对应的参数θ 即为解。为了推导方便，首先研究只有一个训练样本时，如何计算推导公式。

θ 的每个分量更新公式为：

推广到m个训练数据，参数更新公式为：

三、逻辑回归模型

逻辑回归与线性回归同属广义线性模型，逻辑回归是以线性回归为理论支持，是一个二分类模型，也可以推广多到分类问题，通过Sigmoid函数引入了非线性因素，因此可以轻松处理0/1分类问题，首先介绍一下Sigmoid函数：

sigmoid函数图像是一个S曲线，取值在[0, 1]之间，在远离0的地方函数的值会很快接近0或者1，sigmoid函数的求导特性是：

逻辑回归的预测函数是下图，只是在特征到结果的映射中加入了一层函数映射，先把特征线性求和，然后使用函数g(z)将最为假设函数来预测。g(z)可以将连续值映射到0到1之间：

通过求似然函数，两边取log后，对θ求偏导：

这样我们就得到了梯度上升每次迭代的更新方向，那么θ的迭代表达式为：

发现同线性回归模型是同一个表达式，这并不仅仅是巧合，两者存在深层的联系；

四、回归模型使用

数据是2014年5月至2015年5月美国King County的房屋销售价格以及房屋的基本信息。数据分为训练数据和测试数据，分别保存在kc_train.csv和kc_test.csv两个文件中，其中训练数据主要包括10000条记录，14个字段：销售日期,销售价格,卧室数,浴室数,房屋面积,停车面积,楼层数,房屋评分,建筑面积,地下室面积,建筑年份,修复年份,纬度,经度。

import pandas as pd
from pandas import DataFrame
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LinearRegression
# 数据读取
baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\houre_price\\"
house_df=pd.read_csv(baseUrl+'train.csv' )
test_df=pd.read_csv(baseUrl+'test.csv')
house_df.head()

# 删除无关变量
house_df=house_df.drop(['saleTime','year','repairYear','latitude','longitude','buildingSize'],axis=1)
test_df=test_df.drop(['saleTime','year','repairYear','latitude','longitude','buildingSize'],axis=1)

# 模型建立
X_price=house_df.drop(['price'],axis=1)
# X_price.head()
Y_price=house_df['price']
Y_price.head()

LR_reg=LinearRegression()
LR_reg.fit(X_price, Y_price)
Y_pred = LR_reg.predict(test_df)
LR_reg.score(X_price, Y_price)


# 可以选择进行特征缩放
#new_house=house_df.drop(['price'],axis=1)
#from sklearn.preprocessing import MinMaxScaler
#minmax_scaler=MinMaxScaler().fit(new_house)   #进行内部拟合，内部参数会发生变化
#scaler_housing=pd.DataFrame(minmax_scaler.transform(new_house),columns=new_house.columns)

#mm=MinMaxScaler()
#mm.fit(test_df)
#scaler_t=mm.transform(test_df)
#scaler_t=pd.DataFrame(scaler_t,columns=test_df.columns)

02

决策树

一、决策树算法理解

决策树是直观运用概率分析的树形分类器，是很常用的分类方法，属于监管学习，决策树分类过程是从根节点开始，根据特征属性值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。

比如说买瓜的时候，根据瓜的某些特征属性直观判断瓜的好坏，下图依次根据纹理清晰度、根蒂、色泽、触感4个进行分类，生活中我们会将某个最重要或最明显的分类属性放在第一位，然后是次重要属性，这很符合我们平常的判断思维，这就是决策树！

在特征属性非常大的时候，就出现了首选哪个特征属性进行分类？如何剪枝？分类的层次是多少？....系列问题，这些就是决策树构建的核心问题，而且不可能再通过生活直觉判，这时候就要运用数学思维。根据上面问题的不同解决方案，决策树又分为了ID3(熵增益)、C4.5(熵增益率)、CART几种同类算法。

二、熵增益（ID3）

通信层面，信息熵衡量信息的不确定性，信息熵越大表明信息越不准确，可以用信息熵的减少值来衡量信息的价值。在决策树模型中把信息确定性叫做熵增益，有了熵增益后，我们就可以根据熵增益来判断特征值的重要程度，从而选取最重要的特征作为第一次切分，再根据相同的方法用其他特征进行切分，直到得到得到每个划分的叶子节点。信息熵的定义是：

以某个特征属性值切分后子集熵的和称为条件A下的熵，也叫做条件熵，可以如下表示：

分类前的信息熵减去条件熵，得到熵增益：

比如说有以下数据集（相亲结果表lol..）

6条数据中相中（4个）与不想中（2个），暂且不关系如何进行分类，我们首先计算这个分类结果的信息熵：

其次，我们计算“富”属性的条件信息熵，6条数据中“富”与否各半，其中3个“富”都被分类到“相中”，3个“不富”都被分到“不想中”：

两者之差就是我们想要得到的熵增益：

计算各个特征属性的熵增益后，比较哪个熵增益最大，就选择该属性做第一分类特征。

3、熵增益率（C4.5） 按照熵增益最大准则的ID3算法，遇到全部都是非重复值（类似ID）属性容易造成过拟合，因为如果根据ID这个属性进行划分发现此时的熵增益是最大的：

信息增益率定义为：

其中info就是该特征属性中，属性值的信息熵：

按照上面的例子计算，“富”的增益率为：

4、剪枝处理

当训练数据量大、特征数量较多时构建的决策树过于庞大时，可能对训练集依赖过多，也就是对训练数据过度拟合。从训练数据集上看，拟合效果很好，但对于测试数据集或者新的实例来说，并不一定能够准确预测出其结果。因此，对于决策树的构建还需要最后一步--决策树的修剪，主要分为2种：预剪枝（Pre-Pruning）和后剪枝（Post-Pruning），这里先不讲。

5、鸢尾花(iris)分类模型

Iris 鸢尾花数据集是一个经典数据集，在统计学习和机器学习领域都经常被用作示例。数据集内包含 3 类共 150 条记录，每类各 50 个数据，每条记录都有 4 项特征：花萼长度、花萼宽度、花瓣长度、花瓣宽度，可以通过这4个特征预测鸢尾花卉属于（iris-setosa, iris-versicolour, iris-virginica）中的哪一品种，数据集地址：https://github.com/yezonggang/iris

import pandas as pd
from pandas import DataFrame
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics 

baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\iris\\"
iris_df=pd.read_csv(baseUrl+"iris.csv")
iris_df.head()
iris_df.describe()

数据分布探索：

# pandas 自带的散点图
iris_df.plot(kind="scatter", x="Sepal.Length", y="Sepal.Width")

# seaborn 的联合分布图
sns.jointplot(x="Sepal.Length", y="Sepal.Width", data=iris_df, height=5)

# 上面的两个散点图并不能显示每一个点所属的类别
# 所以，接下来用 seaborn 的 FacetGrid 函数按照Species花的种类来在散点图上标上不同的颜色，hue英文是色彩的意思。
sns.FacetGrid(iris_df, hue="Species", height=5).map(plt.scatter, "Sepal.Length", "Sepal.Width").add_legend()

# 通过箱线图来查看单个特征的分布
# 对 Numerical Variable，可以用 Box Plot 来直观地查看不同花类型的分布。
sns.boxplot(x="Species", y="Sepal.Length", data=iris_df)

# 下面的操作，将每一个Species所属的点加到对应的位置，加上散点图，
# 振动值jitter=True 使各个散点分开，要不然会是一条直线
# 注意此处要将坐标图用ax先保存起来，这样第二次才会在原来的基础上加上散点图
ax = sns.boxplot(x="Species", y="Sepal.Length", data=iris_df)
ax = sns.stripplot(x="Species", y="Sepal.Length", data=iris_df, jitter=True, edgecolor="gray")

# violinplot 小提琴图，查看密度分布，结合了前面的两个图，并且进行了简化
# 数据越稠密越宽，越稀疏越窄
sns.violinplot(x="Species", y="Sepal.Length", data=iris_df, height=6)
 # sns.kdeplot == kernel density 核密度图（单个变量）
sns.FacetGrid(iris_df, hue="Species", height=6).map(sns.kdeplot, "Sepal.Length").add_legend()
 # pairplot 任意两个变量间的关系
sns.pairplot(iris_df, hue="Species", height=3)

# 模型构建比较简单，关键是模型的调参
train_df=test_df=iris_df.sample(frac=0.8,replace=False, random_state=None)
train_X=train_df.drop(['Species'],axis=1)
train_Y=train_df['Species']
# 由于么有提供建模数据集，所以我们随机从样本集中选择40%的数据集
# replace=False 无放回的抽取
# random-state 数据不能重复
test_df=iris_df.sample(frac=0.9,replace=False, random_state=None)
test_df.head()

test_X=test_df.drop(['Species'],axis=1)
test_Y=test_df['Species']

model=DecisionTreeClassifier()
model.fit(train_X, train_Y)
prediction = model.predict(test_X)
print('The accuracy of the Decision Tree is: {0}'.format(metrics.accuracy_score(prediction,test_Y)))

分类决策树总共有12个参数可以自己调整，这么多参数一个个记起来太麻烦，我们可以把这些参数分成几个类别： 1）分类策略：有两个参数 ‘entropy’（熵） 和 ‘gini’（基尼系数）可选，默认为gini。 2）max_depth（树的最大深度）：默认为None，此时决策树在建立子树的时候不会限制子树的深度。也可以设置具体的整数，一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间。 3）min_samples_split（分割内部节点所需的最小样本数）：意思就是只要在某个结点里有k个以上的样本，这个节点才需要继续划分，这个参数的默认值为2，也就是说只要有2个以上的样本被划分在一个节点，如果这两个样本还可以细分，这个节点就会继续细分 4）min_samples_leaf（叶子节点上的最小样本数）：当你划分给某个叶子节点的样本少于设定的个数时，这个叶子节点会被剪枝，这样可以去除一些明显异常的噪声数据。默认为1，也就是说只有有两个样本类别不一样，就会继续划分。如果是int，那么将min_samples_leaf视为最小数量。如果为float，则min_samples_leaf为分数，ceil(min _ samples _ leaf * n _ samples)为每个节点的最小样本数。

03

朴素贝叶斯

1、朴素贝叶斯算法

朴素贝叶斯算法依据概率论中贝叶斯定理建立模型，前提假设各个特征之间相互独立（这也是正式“朴素”的含义），这个假设非常极端，因为实际场景中多个特征一般存在相关性，特征相对独立的假设使得算法变得简单，因此在特征值有强相关性的场景中容易出现分类不准的问题。

其数学原理很容易理解：如果你看到一个人总是做好事，则会推断那个人多半会是一个好人。这就是说，当你不能准确判断时候，可以依靠事物特定本质相关的事件出现的多少（概率）作为判断依据，贝叶斯定理：

该公式表示在B发生的条件下A发生的条件概率，等于A事件发生条件下B事件发生的条件概率乘以A事件的概率，再除以B事件发生的概率。公式中，P(A)叫做先验概率，P(A/B)叫做后验概率。

举个栗子：一个非常炎热的夏天晚上，走在校园里面，伸手不见五指.......lol，这个时候迎面走来一个人，太远看不清楚ta的性别，但我们知道ta的特征是“短裤+短发”，而且事先有一些学生的调查样本，需要你根据某些特性大致判断Ta的性别，请问你应该怎么分类？

这样分析，我们首先计算求得P(boy|短裤短发)和P(girl|短裤短发)然后比较两者大小，作为依据判定性别，也就是我们根据以往数据中穿着短裤短发的人中boy和girl的条件概率作为依据，来判断当我们看见“短裤短发”人的性别，在这个例子中我们很明显把ta判定是个boy，核心思想就是这么简单：

2、拉普拉斯修正

由于特征空间较为稀疏，因此，常常会出现概率为0的情况，在这种情况下，需要对其进行一些修正。常用的修正方法是拉普拉斯修正法，就是使得计算条件概率时候分子+1，很容易理解；

蘑菇数据集

该数据集包含了8124个样本和22个变量（如蘑菇的颜色、形状、光滑度等），是机器学习分类算法算法不可多得的一个优质数据集。

3、数据探索

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# 修改baseUrl的路径即可完成数据读取修改
baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\bayes\\"
mushrooms=pd.read_csv(baseUrl+"mushrooms.csv")
mushrooms.columns=['class','cap-shape','cap-surface','cap-color','ruises','odor','gill-attachment','gill-spacing','gill-size','gill-color','stalk-shape','stalk-root','stalk-surface-above-ring','stalk-surface-below-ring','stalk-color-above-ring','stalk-color-below-ring','veil-type','veil-color','ring-number','ring-type','spore-print-color','population','habitat']
mushrooms.shape

pd.set_option("display.max_columns",100) #让所有列都能加载出来
mushrooms.head()
# 可以发现，所有特征都是离散的，都属于分类型

# class标识有毒无毒
np.unique(mushrooms['cap-shape'])

fig,(ax1,ax2)=plt.subplots(1,2,figsize=(15,5))
# 探究 形状和颜色对于是否有毒的贡献度，发现形状为b的无毒蘑菇比例大
sns.countplot(x='cap-shape',data=mushrooms,hue='class',ax=ax1)
sns.countplot(x='cap-surface',data=mushrooms,hue='class',ax=ax2)

sns.countplot(x='cap-color',hue='class',data=mushrooms)

# 把有毒无毒换成0/1类型，1标识无毒
mushrooms['class'].replace('e',1,inplace=True)
mushrooms['class'].replace('p',0,inplace=True)
# 计算每个颜色无毒的概率
perc = mushrooms[["cap-color", "class"]].groupby(['cap-color'],as_index=False).mean()
perc
sns.barplot(x='cap-color',y='class',data=perc)

# 使用sklearn进行预处理
from sklearn.preprocessing import LabelEncoder
labelencoder=LabelEncoder()
for col in mushrooms.columns:
    mushrooms[col] = labelencoder.fit_transform(mushrooms[col])

mushrooms.head()

sns.countplot(x='cap-shape',data=mushrooms,hue='class',)

4、建立模型

X=mushrooms.drop('class',axis=1) #Predictors
y=mushrooms['class'] #Response
#X.head()

#这里采用用哑变量编码，为的是后面能更好的计算特征的各属性的重要性，并且避免数值变量分类时偏向于数值大的属性
X=pd.get_dummies(X,columns=X.columns,drop_first=True)
X.head()

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

# 贝叶斯
from sklearn.naive_bayes import GaussianNB
from sklearn import metrics 
model2 = GaussianNB()
model2.fit(X_train, y_train)
prediction2 = model2.predict(X_test)
print('The accuracy of the Decision Tree is: {0}'.format(metrics.accuracy_score(prediction2,y_test)))

04

K-means聚类

1、算法描述

所谓物以类聚-人以群分，“类”指的是具有相似性的集合，聚类是指将数据集划分为若干类，使得各个类之内的数据最为相似，而各个类之间的数据相似度差别尽可能的大。聚类分析就是以相似性为基础，在一个聚类中的模式之间比不在同一个聚类中的模式之间具有更多的相似性。对数据集进行聚类划分，属于无监督学习。

K-Means是最常用且简单的聚类算法，最大特点是好理解，运算速度快，时间复杂度近于线性，适合挖掘大规模数据集。但是只能应用于连续型的数据，并且一定要在聚类前需要手工指定要分成几类；

K-Means采用距离作为相似性指标，从而发现给定数据集中的K个类，且每个类的中心是根据类中所有数值的均值得到的，每个类的中心用聚类中心来描述。对于给定的一个（包含n个一维以及一维以上的数据点的）数据集X以及要得到的类别数量K，选取欧式距离作为相似度指标，聚类目标是使得类的聚类平方和最小，即最小化：

2、K-Means算法流程：

1. 随机选取K个样本作为聚类中心；
2. 计算各样本与各个聚类中心的距离；
3. 将各样本回归于与之距离最近的聚类中心；
4. 求各个类的样本的均值，作为新的聚类中心；
5. 判定：若类中心不再发生变动或者达到迭代次数，算法结束，否则回到第二步。

from sklearn import datasets
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
URL="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\K-means\\"
data=pd.read_csv(URL+"xigua.csv")
data.head()
data.describe()
fig,(axis1,axis2) = plt.subplots(1,2,figsize=(10,3))
sns.distplot(data["density"],ax=axis1)
sns.distplot(data["sugercontent"],ax=axis2)
sns_test=sns.scatterplot(x="density",y="sugercontent",data=data)
import sklearn.cluster as sc
# n_clusters: 聚类数
model = sc.KMeans(n_clusters=4)
# 不断调整聚类中心，直到最终聚类中心稳定则聚类完成
model.fit(data)
# 获取训练结果的聚类中心
centers = model.cluster_centers_

n_clusters：整型，缺省值=8 ，生成的聚类数。

max_iter：整型，缺省值=300 ，执行一次k-means算法所进行的最大迭代数。

n_init：整型，缺省值=10 ，用不同的聚类中心初始化值运行算法的次数，最终解是在inertia意义下选出的最优结果。

init：有三个可选值：’k-means++’， ‘random’，或者传递一个ndarray向量，此参数指定初始化方法，默认值为 ‘k-means++’。（１）‘k-means++’ 用一种特殊的方法选定初始聚类，可加速迭代过程的收敛（２）‘random’ 随机从训练数据中选取初始质心。（３）如果传递的是一个ndarray，则应该形如 (n_clusters, n_features) 并给出初始质心。

precompute_distances：三个可选值，‘auto’，True 或者 False，预计算距离，计算速度更快但占用更多内存。（１）‘auto’：如果 样本数乘以聚类数大于 12million 的话则不预计算距离。（２）True：总是预先计算距离。（３）False：永远不预先计算距离。

tol：float类型，默认值= 1e-4　与inertia结合来确定收敛条件。

n_jobs：整形数。　指定计算所用的进程数。内部原理是同时进行n_init指定次数的计算。（１）若值为 -1，则用所有的CPU进行运算。若值为1，则不进行并行运算。（２）若值小于-1，则用到的CPU数为(n_cpus + 1 + n_jobs)。因此如果 n_jobs值为-2，则用到的CPU数为总CPU数减1。

random_state：整型或 numpy.RandomState 类型，可选，用于初始化质心的生成器（generator）。如果值为一个整数，则确定一个seed。此参数默认值为numpy的随机数生成器。

copy_x：布尔型，默认值=True 　　，当我们precomputing distances时，将数据中心化会得到更准确的结果。如果把此参数值设为True，则原始数据不会被改变。如果是False，则会直接在原始数据上做修改并在函数返回值时将其还原。但是在计算过程中由于有对数据均值的加减运算，所以数据返回后，原始数据和计算前可能会有细小差别。

05

关联规则挖掘

1、关联规则简介

关联规则挖掘可以让我们从数据集中发现项与项之间的关系，它在我们的生活中有很多应用场景，“购物篮分析”就是一个常见的场景，这个场景可以从消费者交易记录中发掘商品与商品之间的关联关系，进而通过商品捆绑销售或者相关推荐的方式带来更多的销售量。

1. 搞懂关联规则中的几个重要概念：支持度、置信度、提升度
2. Apriori 算法的工作原理
3. 在实际工作中，我们该如何进行关联规则挖掘

2、关联规则中重要的概念

我举一个超市购物的例子，下面是几名客户购买的商品列表：

支持度

支持度是个百分比，它指的是某个商品组合出现的次数与总次数之间的比例。支持度越高，代表这个组合出现的频率越大。

我们看啤酒出现了3次，那么5笔订单中啤酒的支持度是3/5=0.6。同理，尿布出现了5次，那么尿布的支持度是5/5=1。尿布和啤酒同时出现的支持度是3/6=0.6。

置信度

它指的就是当你购买了商品 A，会有多大的概率购买商品 B。

我们可以看上面的商品，购买尿布的同时又购买啤酒的订单数是3，购买啤酒的订单数是3，那么（尿布->啤酒）置信度= 3/3=1。

再看购买了啤酒同时购买尿布的订单数是3，购买尿布的订单数是5，那么（啤酒->尿布）置信度=3/5=0.6。

提升度

提升度代表的是“商品 A 的出现，对商品 B 的出现概率提升的”程度。所以我们在做商品推荐的时候，重点考虑的是提升度。

我们来看提升度公式：

那么我们来计算下尿布对啤酒的提升度是多少：

怎么解读1.67这个数值呢？

1. 提升度 (A→B)>1：代表有提升
2. 提升度 (A→B)=1：代表有没有提升，也没有下降
3. 提升度 (A→B)<1：代表有下降。

其实看上面提升度的公式，我们就可以理解，也就是AB同时出现的次数越多，单独出现B的次数越少，那么支持度也就越大也就是B的出现总是伴随着A的出现，那么A对B出现的概率就越有提升！

3、Apriori 的工作原理

我们一起来看下经典的关联规则 Apriori 算法是如何工作的。

Apriori 算法其实就是查找频繁项集 (frequent itemset) 的过程，所以我们需要先了解是频繁项集。

频繁项集就是支持度大于等于最小支持度阈值的项集，所以小于最小值支持度的项目就是非频繁项集，而大于等于最小支持度的项集就是频繁项集。

下面我们来举个栗子：

假设我随机指定最小支持度是0.2。首先，我们先计算单个商品的支持度：

因为最小支持度是 0.2，所以你能看到商品 鸡蛋 是不符合最小支持度的，不属于频繁项集，于是经过筛选商品的频繁项集如下：

在这个基础上，我们将商品两两组合，得到两个商品的支持度：

筛选大于最小支持度（0.2）的数据后

在这个基础上，我们再将商品三个组合，得到三个商品的支持度：

筛选大于最小支持度（0.2）的数据后

在这个基础上，我们将商品四个组合，得到四个商品的支持度：

再次筛选大于最小支持度（0.2）数据的话，就全删除了，那么，此时算法结束，上一次的结果就是我们要找的频繁项，也就是{牛奶、面包、尿布}、{面包、尿布、啤酒}。

我们来总结一下上述Apriori算法过程：

1. K=1，计算 K 项集的支持度
2. 筛选掉小于最小支持度的项集
3. 如果项集为空，则对应 K-1 项集的结果为最终结果
4. 否则 K=K+1，重复 1-3 步

我们可以看到 Apriori 在计算的过程中有以下几个缺点：

1. 可能产生大量的候选集。因为采用排列组合的方式，把可能的项集都组合出来了
2. 每次计算都需要重新扫描数据集，来计算每个项集的支持度

这就好比我们数据库中的“全表扫描”查询一样，非常浪费IO和时间。在数据库中我们都知道使用索引来快速检索数据，那Apriori 能优化吗？

4、Apriori 的改进算法：FP-Growth 算法

FP-growth算法是基于Apriori原理的，通过将数据集存储在FP树上发现频繁项集，但不能发现数据之间的关联规则。FP-growth算法只需要对数据库进行两次扫描，而Apriori算法在求每个潜在的频繁项集时都需要扫描一次数据集，所以说Apriori算法是高效的。其中算法发现频繁项集的过程是：(1)构建FP树；(2)从FP树中挖掘频繁项集。

创建项头表

概念知识不在这凑字数了，我们直接来干货！假设我们从以下数据中来挖掘频繁项。

首先创建，项头表，这一步的流程是先扫描一遍数据集，对于满足最小支持度的单个项按照支持度从高到低进行排序，这个过程中删除了不满足最小支持度的项（假设最小支持度是0.2）。

构建FP树

整个流程是需要再次扫描数据集，对于每一条数据，按照支持度从高到低的顺序进行创建节点（也就是第一步中项头表中的排序结果），节点如果存在就将计数 count+1，如果不存在就进行创建。同时在创建的过程中，需要更新项头表的链表。

先把原始数据按照支持度排序，那么原始数据变化如下：

下面我们把以上每行数据，按照顺序插入到FP树中，注意FP树的根节点记为 NULL 节点。

接下来插入第二行数据，由于第二行数据第一个数据也是B，和已有的树结构重合，那么我们保持原来树结构中的B位置不变，同时计数加1，C、D是新增数据，那么就会有新的树分叉，结果如下图：

以此类推，读取下面的三行数据到FP树中

最后生成的FP数如下：

根据FP数挖掘频繁项

我们终于把FP树建立好了，那么如何去看这颗树呢？得到 FP 树后，需要对每一个频繁项，逐个挖掘频繁项集。具体过程为：首先获得频繁项的前缀路径，然后将前缀路径作为新的数据集，以此构建前缀路径的条件 FP 树。然后对条件 FP 树中的每个频繁项，获得前缀路径并以此构建新的条件 FP 树。不断迭代，直到条件 FP 树中只包含一个频繁项为止（反正我第一次看完这句话是没理解）。

FP树是从下往上看了，也就是根据子节点找父节点，接下来还是来图解~

首先，我们看包含A的频繁项：

我们可以看到包含A的树有两个，我们先看树2，可以得到路径{B:2,C:2}，此处的2是根据A出现的次数定的。接着我们创建FP树，具体的创建过程和上面创建 FP 树的过程一样，如下图：

注意此时头指针表中包含两个元素，所以对每个元素，需要获得前缀路径，并将前缀路径创建成条件 FP 树，直到条件 FP 树中只包含一个元素时返回。

• 对元素 B，获得前缀路径为{}，则频繁项集返回{A:2,B:2};
• 对元素 C，获得前缀路径{B:2}，则将前缀路径创建成条件 FP 树，如下图 所示。 注意此时条件 FP 树中只包含一个元素，故返回频繁项集{A:2,C:2,B:2}。由于元素 C 也是频繁项，所以{A:2,C:2}也是频繁项集。

再加上{A:2}本身就是频繁项集，所以 A 对应的频繁项集有：{A:2},{A:2,C:2} ,{A:2,B:2},{A:2,C:2,B:2}。

同理，我们来看树1，树1比较简单，就一个路径{B:1}，根据上述方法我们得到此分支频繁项为{A:1,B:1},{A:1}。

综上，我们可以看到两个分支都包含频繁项{A,B},{A}的，此时我们进行合并两个分支，得到包含A的频繁项：{A:3},{A:3,B:3},{A:2,C:2} ,{A:2,C:2,B:2}，我们用出现的次数转换下，即 (A,): 3, (A, B): 3, (A, C): 2, (A, B, C): 2。

同理，按照上述方法，我们可以依次找到包含B的频繁项是(D): 2, (C, D): 2, (B, D): 2, (B, C, D): 2, (C): 4, (B, C): 4, (B): 5。

5、实践总结

经典的算法，很多大神已经实现，我们直接拿来用就行了，比如上面的FP-GROWTH算法，介绍一款专门的包pyfpgrowth。

代码：

import pyfpgrowth as fp

itemsets = [['A','B'], ['B','C','D'],['B','C'],['A','B','C'],['A','B','C','D']]
# 频数删选  频数大于2
patterns = fp.find_frequent_patterns(itemsets, 2)
print(patterns)

#输出 {('D',): 2, ('C', 'D'): 2, ('B', 'D'): 2, ('B', 'C', 'D'): 2, ('A',): 3, ('A', 'B'): 3, ('A', 'C'): 2, ('A', 'B', 'C'): 2, ('C',): 4, ('B', 'C'): 4, ('B',): 5}

—END—