【机器学习】【Apriori算法-1】Apriori算法原理详解 + 示例展示数学求解过程

1.Apriori算法原理详解

Apriori算法是经典的挖掘频繁项集和关联规则的数据挖掘算法。A priori在拉丁语中指"来自以前"。当定义问题时，通常会使用先验知识或者假设，这被称作"一个先验"（a priori）。Apriori算法的名字正是基于这样的事实：算法使用频繁项集性质的先验性质，即频繁项集的所有非空子集也一定是频繁的。Apriori算法使用一种称为逐层搜索的迭代方法，其中k项集用于探索(k+1)项集。首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。该集合记为L1。然后，使用L1找出频繁2项集的集合L2，使用L2找出L3，如此下去，直到不能再找到频繁k项集。每找出一个Lk需要一次数据库的完整扫描。Apriori算法使用频繁项集的先验性质来压缩搜索空间。

2.数学示例求解过程

给个整体求解手稿：

下面以商品交易为例介绍数学求解过程，展示Apriori算法的思路。

注：手稿中由于[1,2,3,5]在交易中出现1次，导致最后支持数据集为[]，所以为了很好展示Apriori算法思路，下面在商品交易列表中出现了2次[1,2,3,5]交易记录，会让最后求得的支持数据集不为空~

自定义最小支持度为0.2，即minSupport=0.2，即小于最小支持度的频繁项不会添加到支持数据集中~

商品交易记录列表goods：

    goods = np.array([[1, 2, 5],
                      [2, 4],
                      [2, 3],
                      [1, 2, 4],
                      [1, 3],
                      [2, 3],
                      [1, 3],
                      [1, 2, 3, 5],
                      [1, 2, 3, 5],
                      [1, 2, 3]])

第一步：求初始化数据集

说明：[[1], 7]，其中[1]是一个频繁项，7是此频繁项对应的支持项，表示频繁项[1]在商品交易记录列表中出现7次

supportData:

[[[1], 7], 
 [[2], 8], 
 [[3], 7], 
 [[4], 2], 
 [[5], 3]] 

第二步：支持项过滤

自定义最小支持度为minSupport = 0.2，则最小支持项=0.2*N=0.2*10=2

则由于每个支持项都不小于最小支持项，则每个频繁项都不被丢弃

第三步：发现新的支持数据集+支持度过滤

发现规则：根据已有的支持数据集supportData，然后按照下面步骤产生新的支持数据集

说明：频繁项如何生成，支持度如何得到，如何进行支持度过滤？

supportData中第一个繁琐项是[1]则和其后面的频繁项[2], [3], [4], [5]依次按照下面规则生成频繁项。举例[1]和[2]的过程，其他一模一样。

频繁项：[1]和[2]，合并得到[1, 2]，[1, 2]就是由旧的频繁项[1]和[2]组合成的新的频繁项

支持项：新的频繁项[1, 2]在商品交易列表中出现的次数，查一查发现出现过5次，则频繁项[1, 2]的支持项为5

支持度：5次/交易总次数=5/10=0.5

支持度过滤：因为0.5 > 最小支持度0.2，经过支持度过滤，增加[[1, 2], 5.0]到新的支持数据集~

下面的求解步骤中，频繁项[1, 4]的支持度0.1 < 最小支持度0.2，所以丢弃[[1, 4], 1]，不增加到新的支持数据集中。

[1] go to 发现新的频繁项:  
         [1] 和 [2] 组合成频繁项: [1, 2] 支持度: 0.5 经过支持度过滤，增加此项: [[1, 2] 5.0]  
         [1] 和 [3] 组合成频繁项: [1, 3] 支持度: 0.5 经过支持度过滤，增加此项: [[1, 3] 5.0]  
         [1] 和 [4] 组合成频繁项: [1, 4] 支持度: 0.1 经过支持度过滤，丢弃此项: [[1, 4] 1.0]  
         [1] 和 [5] 组合成繁琐项: [1, 5] 支持度: 0.3 经过支持度过滤，增加此项: [[1, 5] 3.0]  
  
 [2] go to 发现新的频繁项:  
         [2] 和 [3] 组合成频繁项: [2, 3] 支持度: 0.5 经过支持度过滤，增加此项: [[2, 3] 5.0]  
         [2] 和 [4] 组合成频繁项: [2, 4] 支持度: 0.2 经过支持度过滤，增加此项: [[2, 4] 2.0]  
         [2] 和 [5] 组合成频繁项: [2, 5] 支持度: 0.3 经过支持度过滤，增加此项: [[2, 5] 3.0]  
  
 [3] go to 发现新的频繁项:  
         [3] 和 [4] 组合成频繁项: [3, 4] 支持度: 0.0 经过支持度过滤，丢弃此项: [[3, 4] 0.0]  
         [3] 和 [5] 组合成频繁项: [3, 5] 支持度: 0.2 经过支持度过滤，增加此项: [[3, 5] 2.0]  
  
 [4] go to 发现新的频繁项:  
         [4] 和 [5] 组合成频繁项: [4, 5] 支持度: 0.0 经过支持度过滤，丢弃此项: [[4, 5] 0.0]  
  
 [5] go to 发现新的频繁项:  
  
new_supportData:  
 [[[1, 2] 5.0]  
 [[1, 3] 5.0]  
 [[1, 5] 3.0]  
 [[2, 3] 5.0]  
 [[2, 4] 2.0]  
 [[2, 5] 3.0]  
 [[3, 5] 2.0]]  

上面的new_supportData就是最新的经过支持度过滤的支持数据集。

第四步：重复第三步--->发现新的支持数据集+支持度过滤

继续的原因是，现已supportData中的频繁项比如[1, 2]长度为2， 而商品交易记录中的记录项最长为4，如[1,2,3,5]

所以需要继续发现新的支持数据集，直到支持的频繁项长度达到交易记录项的最长长度4。

1）“ [1, 2]和[1, 3]无法组合生成新的频繁项”的思路：因为[1, 2]的最后一个商品2在[1, 3]中没有出现，所以无新频繁项产生

2）“[1, 3]和[2, 3]无法组合生成新的频繁项”的思路：因为[1,3]的最后一个商品3在[1,3]中是最后一个出现，所以无新频繁项产生，因为不能组合生成[1, 3, 3]

[1, 2] go to 发现新的频繁项:  
         [1, 2] 和 [1, 3] 无法组合成新的频繁项.  
         [1, 2] 和 [1, 5] 无法组合成新的频繁项.  
         [1, 2] 和 [2, 3] 组合成频繁项: [1, 2, 3] 支持度: 0.3 经过支持度过滤，增加此项: [[1, 2, 3] 3.0]  
         [1, 2] 和 [2, 4] 组合成频繁项: [1, 2, 4] 支持度: 0.1 经过支持度过滤，丢弃此项: [[1, 2, 4] 1.0]  
         [1, 2] 和 [2, 5] 组合成频繁项: [1, 2, 5] 支持度: 0.3 经过支持度过滤，增加此项: [[1, 2, 5] 3.0]  
         [1, 2] 和 [3, 5] 无法组合成新的频繁项.  
  
 [1, 3] go to 发现新的频繁项:  
         [1, 3] 和 [1, 5] 无法组合成新的频繁项.  
         [1, 3] 和 [2, 3] 无法组合成新的频繁项.  
         [1, 3] 和 [2, 4] 无法组合成新的频繁项.  
         [1, 3] 和 [2, 5] 无法组合成新的频繁项.  
         [1, 3] 和 [3, 5] 组合成频繁项: [1, 3, 5] 支持度: 0.2 经过支持度过滤，增加此项: [[1, 3, 5] 2.0]  
  
 [1, 5] go to 发现新的频繁项:  
         [1, 5] 和 [2, 3] 无法组合成新的频繁项.  
         [1, 5] 和 [2, 4] 无法组合成新的频繁项.  
         [1, 5] 和 [2, 5] 无法组合成新的频繁项.  
         [1, 5] 和 [3, 5] 无法组合成新的频繁项.  
  
 [2, 3] go to 发现新的频繁项:  
         [2, 3] 和 [2, 4] 无法组合成新的频繁项.  
         [2, 3] 和 [2, 5] 无法组合成新的频繁项.  
         [2, 3] 和 [3, 5] 组合成频繁项: [2, 3, 5] 支持度: 0.2 经过支持度过滤，增加此项: [[2, 3, 5] 2.0]  
  
 [2, 4] go to 发现新的频繁项:  
         [2, 4] 和 [2, 5] 无法组合成新的频繁项.  
         [2, 4] 和 [3, 5] 无法组合成新的频繁项.  
  
 [2, 5] go to 发现新的频繁项:  
         [2, 5] 和 [3, 5] 无法组合成新的频繁项.  
  
 [3, 5] go to 发现新的频繁项:  
  
new_supportData:  
 [[[1, 2, 3] 3.0]  
 [[1, 2, 5] 3.0]  
 [[1, 3, 5] 2.0]  
 [[2, 3, 5] 2.0]]  

第五步：重复第三步--->发现新的支持数据集+支持度过滤

继续原因是，现有支持频繁项长度是3，如[1,2,3]，小于交易记录项的最长长度4。

[1, 2, 3] go to 发现新的频繁项:  
         [1, 2, 3] 和 [1, 2, 5] 无法组合成新的繁琐项.  
         [1, 2, 3] 和 [1, 3, 5] 组合成繁琐项: [1, 2, 3, 5] 支持度: 0.2 经过支持度过滤，增加此频繁项: [[1, 2, 3, 5] 2.0]  
         [1, 2, 3] 和 [2, 3, 5] 组合成繁琐项: [1, 2, 3, 5] 支持度: 0.2 经过支持度过滤，增加此频繁项: [[1, 2, 3, 5] 2.0]  
  
 [1, 2, 5] go to 发现新的频繁项:  
         [1, 2, 5] 和 [1, 3, 5] 无法组合成新的繁琐项.  
         [1, 2, 5] 和 [2, 3, 5] 无法组合成新的繁琐项.  
  
 [1, 3, 5] go to 发现新的频繁项:  
         [1, 3, 5] 和 [2, 3, 5] 无法组合成新的繁琐项.  
  
 [2, 3, 5] go to 发现新的频繁项:  
  
new_supportData:  
 [[[1, 2, 3, 5] 2.0]  
 [[1, 2, 3, 5] 2.0]]  
Apriori over, supportData:  
 [[[1, 2, 3, 5] 2.0]  

本次新的支持数据集中频繁项长度为4 等于 交易记录项的最长长度4，所以结束Apriori算法的迭代计算，至此目标支持数据集已经生成：

Apriori over, supportData:  
 [[[1, 2, 3, 5] 2.0]  

算法结果应用：

如果商店拿到此支持数据集结果，可以将1,2,3,5商品摆放的邻近一些，或者搞活动时，这几个一起搞活动，按照算法结果一起买1,2,3,5的情况会很容易出现~，就是很容易出现一起买1,2,3,5商品的情况

上面就是数学求解过程展示Apriori算法的思路，此算法比较简单，用心捋一捋就会掌握算法的求解过程和算法细想。

参考文献

[1]Apriori算法介绍(Python实现)

（end）