作者：数据一哥 来源：数据俱乐部
全文共10793个字，建议阅读
首先，我们来谈谈回归模型。回归模型研究变量（目标）与自变量（预测器）之间的关系，因为变量可以散是分类问题。考虑到房价预测模型，我们可以根据房屋的大小、房屋类型、位置、南北透明度等自变量来预测房屋的价格，这是最简单的回归模型，在初中回归表达一般写，x是自变量，y是因变量，w是特征矩阵，b是偏置。
将线性代数的思想引入机器学习推导，假设我们用表达式来描述假期预测模型，x代表房子的特征集，是房子的特征集n×总共有m个特征集，θ是一个n×列向量是我们想要的未知数。
我们采用最小误差的策略，如预测表达式：y工资=Θ1*学历 Θ2*工作经验 Θ3*技术能力 ... Θn*x 基本工资、预测y值和实际值y_存在差距，战略函数使m个特征收集(真实值y-预测值）的平方和最小。（差值可能是负数，所以采用平方和）；
按照对于正规方程的求法，我们对θ 求偏导：
也就是说，由于变量，给定特征矩阵X和y，也就是说，误差率可以最小化θ值，满足后续回归模型。了解线性代数的童靴可以看到问题θ求逆运算在表达式中，，这通常是无法保证的，这将导致θ战略失战略失效；
常规方程需要大量的矩阵操作，特别是矩阵的反向操作，这将大大提高计算的复杂性。，正式方程法对矩阵偏差有一定的局限性（不能保证矩阵可逆性），以下介绍梯度下降法，即计算机解决方案，每小步，确保这小步是最有效的步骤，你可以想象你在下山，你不知道目的地（最小值）在哪里，但你可以确保你每次都是最陡峭的步骤；
我们的策略保持不变，这是为了收集m个特征（真实值）y-平方和最小预测值：
实现梯度下降法：赋予初始θ 根据公式逐步更新值θ 使得J(θ) 不断减少，最终收敛，相应的参数θ 也就是解。为了方便推导，首先研究如何计算只有一个训练样本的推导公式。
θ 每个重量更新公式为：
参数更新公式为：
逻辑回归和线性回归属于广义线性模型。逻辑回归是基于线性回归的理论支持。它是一个二分类模型，也可以通过分类问题推广更多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培训数据主要包括1万份记录和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)决策树是一种直观利用概率分析的树形分类器，是一种非常常见的分类方法，属于监督学习。决策树的分类过程从根节点开始，根据特征属性值选择输出分支，直到叶节点到达，叶节点存储的类别作为决策结果。
比如买瓜的时候，根据瓜的一些特点和属性，直观判断瓜的质量。下图根据纹理清晰度、根、色、触感四个方面进行分类。在生活中，我们会把最重要或最明显的分类属性放在第一位，然后是次要属性，这与我们平时的判断思维非常一致。这是决策树！
特征属性很大的时候，哪个特征属性是分类的首选？怎么剪？分类的层次是多少？...这些都是决策树建设的核心问题，不可能通过生活直觉来判断。此时，我们应该使用数学思维。根据上述问题的不同解决方案，决策树分为ID3(熵增益)、C4.5.CART几种类似的算法。
在通信层面，信息熵衡量信息的不确定性。信息熵越大，信息就越不准确。息熵的减少值来衡量信息的价值。在决策树模型中把信息确定性叫做熵增益，有了熵增益后，我们就可以根据熵增益来判断特征值的重要程度，从而选取最重要的特征作为第一次切分，再根据相同的方法用其他特征进行切分，直到得到得到每个划分的叶子节点。信息熵的定义是：
以某个特征属性值切分后子集熵的和称为条件A下的熵，也叫做条件熵，可以如下表示：分类前的信息熵减去条件熵，得到熵增益：
比如说有以下数据集（相亲结果表lol..）
6条数据中相中（4个）与不想中（2个），暂且不关系如何进行分类，我们首先计算这个分类结果的信息熵：
其次，我们计算“富”属性的条件信息熵，6条数据中“富”与否各半，其中3个“富”都被分类到“相中”，3个“不富”都被分到“不想中”：
两者之差就是我们想要得到的熵增益：
计算各个特征属性的熵增益后，比较哪个熵增益最大，就选择该属性做第一分类特征。
按照熵增益最大准则的ID3算法，遇到全部都是非重复值（类似ID）属性容易造成过拟合，因为如果根据ID这个属性进行划分发现此时的熵增益是最大的：
信息增益率定义为：
其中info就是该特征属性中，属性值的信息熵：
按照上面的例子计算，“富”的增益率为：
当训练数据量大、特征数量较多时构建的决策树过于庞大时，可能对训练集依赖过多，也就是对训练数据过度拟合。从训练数据集上看，拟合效果很好，但对于测试数据集或者新的实例来说，并不一定能够准确预测出其结果。因此，对于决策树的构建还需要最后一步--决策树的修剪，主要分为2种：预剪枝（Pre-Pruning）和后剪枝（Post-Pruning），这里先不讲。
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个参数可以自己调整，这么多参数一个个记起来太麻烦，我们可以把这些参数分成几个类别： 有两个参数 ‘entropy’（熵） 和 ‘gini’（基尼系数）可选，默认为gini。默认为None，此时决策树在建立子树的时候不会限制子树的深度。也可以设置具体的整数，一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间。意思就是只要在某个结点里有k个以上的样本，这个节点才需要继续划分，这个参数的默认值为2，也就是说只要有2个以上的样本被划分在一个节点，如果这两个样本还可以细分，这个节点就会继续细分当你划分给某个叶子节点的样本少于设定的个数时，这个叶子节点会被剪枝，这样可以去除一些明显异常的噪声数据。默认为1，也就是说只有有两个样本类别不一样，就会继续划分。如果是int，那么将min_samples_leaf视为最小数量。如果为float，则min_samples_leaf为分数，ceil(min _ samples _ leaf * n _ samples)为每个节点的最小样本数。
朴素贝叶斯算法依据概率论中贝叶斯定理建立模型，前提假设各个特征之间相互独立（这也是正式“朴素”的含义），这个假设非常极端，因为实际场景中多个特征一般存在相关性，特征相对独立的假设使得算法变得简单，因此在特征值有强相关性的场景中容易出现分类不准的问题。
其数学原理很容易理解：如果你看到一个人总是做好事，则会推断那个人多半会是一个好人。这就是说，当你不能准确判断时候，可以依靠事物特定本质相关的事件出现的多少（概率）作为判断依据，贝叶斯定理：
该公式表示在B发生的条件下A发生的条件概率，等于A事件发生条件下B事件发生的条件概率乘以A事件的概率，再除以B事件发生的概率。公式中，P(A)叫做先验概率，P(A/B)叫做后验概率。
举个栗子：一个非常炎热的夏天晚上，走在校园里面，伸手不见五指.......lol，这个时候迎面走来一个人，太远看不清楚ta的性别，但我们知道ta的特征是“短裤+短发”，而且事先有一些学生的调查样本，需要你根据某些特性大致判断Ta的性别，请问你应该怎么分类？
这样分析，我们首先计算求得P(boy|短裤短发)和P(girl|短裤短发)然后比较两者大小，作为依据判定性别，也就是我们根据以往数据中穿着短裤短发的人中boy和girl的条件概率作为依据，来判断当我们看见“短裤短发”人的性别，在这个例子中我们很明显把ta判定是个boy，核心思想就是这么简单：
由于特征空间较为稀疏，因此，常常会出现概率为0的情况，在这种情况下，需要对其进行一些修正。常用的修正方法是拉普拉斯修正法，就是使得计算条件概率时候分子+1，很容易理解；
蘑菇数据集
该数据集包含了8124个样本和22个变量（如蘑菇的颜色、形状、光滑度等），是机器学习分类算法算法不可多得的一个优质数据集。
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.shapepd.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',)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)))所谓物以类聚-人以群分，“类”指的是具有相似性的集合，聚类是指将数据集划分为若干类，使得各个类之内的数据最为相似，而各个类之间的数据相似度差别尽可能的大。聚类分析就是以相似性为基础，在一个聚类中的模式之间比不在同一个聚类中的模式之间具有更多的相似性。对数据集进行聚类划分，属于无监督学习。
K-Means是最常用且简单的聚类算法，最大特点是好理解，运算速度快，时间复杂度近于线性，适合挖掘大规模数据集。但是只能应用于连续型的数据，并且一定要在聚类前需要手工指定要分成几类；
K-Means采用距离作为相似性指标，从而发现给定数据集中的K个类，且每个类的中心是根据类中所有数值的均值得到的，每个类的中心用聚类中心来描述。对于给定的一个（包含n个一维以及一维以上的数据点的）数据集X以及要得到的类别数量K，选取欧式距离作为相似度指标，聚类目标是使得类的聚类平方和最小，即最小化：
随机选取K个样本作为聚类中心；
计算各样本与各个聚类中心的距离；
将各样本回归于与之距离最近的聚类中心；
求各个类的样本的均值，作为新的聚类中心；
判定：若类中心不再发生变动或者达到迭代次数，算法结束，否则回到第二步。
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，则会直接在原始数据上做修改并在函数返回值时将其还原。但是在计算过程中由于有对数据均值的加减运算，所以数据返回后，原始数据和计算前可能会有细小差别。
关联规则挖掘可以让我们从数据集中发现项与项之间的关系，它在我们的生活中有很多应用场景，“购物篮分析”就是一个常见的场景，这个场景可以从消费者交易记录中发掘商品与商品之间的关联关系，进而通过商品捆绑销售或者相关推荐的方式带来更多的销售量。
搞懂关联规则中的几个重要概念：支持度、置信度、提升度
Apriori 算法的工作原理
在实际工作中，我们该如何进行关联规则挖掘
我举一个超市购物的例子，下面是几名客户购买的商品列表：
| 订单编号 | 购买商品 |
|---|---|
| 1 | 牛奶、面包、尿布 |
| 2 | 可乐、面包、尿布、啤酒 |
| 3 | 牛奶、尿布、啤酒、鸡蛋 |
| 4 | 面包、牛奶、尿布、啤酒 |
| 5 | 面包、牛奶、尿布、可乐 |
支持度是个百分比，它指的是某个商品组合出现的次数与总次数之间的比例。支持度越高，代表这个组合出现的频率越大。
我们看啤酒出现了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这个数值呢？
提升度 (A→B)>1：代表有提升
提升度 (A→B)=1：代表有没有提升，也没有下降
提升度 (A→B)<1：代表有下降。
其实看上面提升度的公式，我们就可以理解，也就是AB同时出现的次数越多，单独出现B的次数越少，那么支持度也就越大也就是B的出现总是伴随着A的出现，那么A对B出现的概率就越有提升！
我们一起来看下经典的关联规则 Apriori 算法是如何工作的。
Apriori 算法其实就是查找频繁项集 (frequent itemset) 的过程，所以我们需要先了解是频繁项集。
频繁项集就是支持度大于等于最小支持度阈值的项集，所以小于最小值支持度的项目就是非频繁项集，而大于等于最小支持度的项集就是频繁项集。
下面我们来举个栗子：
假设我随机指定最小支持度是0.2。首先，我们先计算单个商品的支持度：
| 购买商品 | 支持度 |
|---|---|
| 牛奶 | 4/5 |
| 面包 | 4/5 |
| 尿布 | 5/5 |
| 可乐 | 2/5 |
| 啤酒 | 3/5 |
| 鸡蛋 | 1/5 |
因为最小支持度是 0.2，所以你能看到商品 鸡蛋 是不符合最小支持度的，不属于频繁项集，于是经过筛选商品的频繁项集如下：
| 购买商品 | 支持度 |
|---|---|
| 牛奶 | 4/5 |
| 面包 | 4/5 |
| 尿布 | 5/5 |
| 可乐 | 2/5 |
| 啤酒 | 3/5 |
在这个基础上，我们将商品两两组合，得到两个商品的支持度：
| 购买商品 | 支持度 |
|---|---|
| 牛奶、面包 | 3/5 |
| 牛奶、尿布 | 4/5 |
| 牛奶、可乐 | 1/5 |
| 牛奶、啤酒 | 2/5 |
| 面包、尿布 | 4/5 |
| 面包、可乐 | 2/5 |
| 面包、啤酒 | 2/5 |
| 尿布、可乐 | 2/5 |
| 尿布、啤酒 | 3/5 |
| 可乐、啤酒 | 1/5 |
筛选大于最小支持度（0.2）的数据后
| 购买商品 | 支持度 |
|---|---|
| 牛奶、面包 | 3/5 |
| 牛奶、尿布 | 4/5 |
| 牛奶、啤酒 | 2/5 |
| 面包、尿布 | 4/5 |
| 面包、可乐 | 2/5 |
| 面包、啤酒 | 2/5 |
| 尿布、可乐 | 2/5 |
| 尿布、啤酒 | 3/5 |
在这个基础上，我们再将商品三个组合，得到三个商品的支持度：
| 购买商品 | 支持度 |
|---|---|
| 牛奶、面包、尿布 | 3/5 |
| 牛奶、面包、可乐 | 1/5 |
| 牛奶、面包、啤酒 | 1/5 |
| 面包、尿布、可乐 | 1/5 |
| 面包、尿布、啤酒 | 2/5 |
| 尿布、可乐、啤酒 | 1/5 |
筛选大于最小支持度（0.2）的数据后
| 购买商品 | 支持度 |
|---|---|
| 牛奶、面包、尿布 | 3/5 |
| 面包、尿布、啤酒 | 2/5 |
在这个基础上，我们将商品四个组合，得到四个商品的支持度：
| 购买商品 | 支持度 |
|---|---|
| 牛奶、面包、尿布、可乐 | 1/5 |
| 牛奶、面包、尿布、啤酒 | 1/5 |
| 面包、尿布、可乐、啤酒 | 1/5 |
再次筛选大于最小支持度（0.2）数据的话，就全删除了，那么，此时算法结束，上一次的结果就是我们要找的频繁项，也就是{牛奶、面包、尿布}、{面包、尿布、啤酒}。
我们来总结一下上述Apriori算法过程：
K=1，计算 K 项集的支持度
筛选掉小于最小支持度的项集
如果项集为空，则对应 K-1 项集的结果为最终结果
否则 K=K+1，重复 1-3 步
我们可以看到 Apriori 在计算的过程中有以下几个缺点：
可能产生大量的候选集。因为采用排列组合的方式，把可能的项集都组合出来了
每次计算都需要重新扫描数据集，来计算每个项集的支持度
这就好比我们数据库中的“全表扫描”查询一样，非常浪费IO和时间。在数据库中我们都知道使用索引来快速检索数据，那Apriori 能优化吗？
FP-growth算法是基于Apriori原理的，通过将数据集存储在FP树上发现频繁项集，但不能发现数据之间的关联规则。FP-growth算法只需要对数据库进行两次扫描，而Apriori算法在求每个潜在的频繁项集时都需要扫描一次数据集，所以说Apriori算法是高效的。其中算法发现频繁项集的过程是：(1)构建FP树；(2)从FP树中挖掘频繁项集。
概念知识不在这凑字数了，我们直接来干货！假设我们从以下数据中来挖掘频繁项。
首先创建，项头表，这一步的流程是先扫描一遍数据集，对于满足最小支持度的单个项按照支持度从高到低进行排序，这个过程中删除了不满足最小支持度的项（假设最小支持度是0.2）。
整个流程是需要再次扫描数据集，对于每一条数据，按照支持度从高到低的顺序进行创建节点（也就是第一步中项头表中的排序结果），节点如果存在就将计数 count+1，如果不存在就进行创建。同时在创建的过程中，需要更新项头表的链表。
先把原始数据按照支持度排序，那么原始数据变化如下：
下面我们把以上每行数据，按照顺序插入到FP树中，注意FP树的根节点记为 NULL 节点。
接下来插入第二行数据，由于第二行数据第一个数据也是B，和已有的树结构重合，那么我们保持原来树结构中的B位置不变，同时计数加1，C、D是新增数据，那么就会有新的树分叉，结果如下图：
以此类推，读取下面的三行数据到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。
经典的算法，很多大神已经实现，我们直接拿来用就行了，比如上面的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—
还给大家准备了一系列机器学习数据，添加我的微信获取~