关联规则分析

本次报告主要包括以下内容：

1. 数据介绍
2. 基本原理介绍
3. 结合理论进行案例分析
4. 最后总结
5. 附录加上参考和代码

数据介绍

本次报告所使用的案例数据为购物篮数据，存储在shop_basket.csv文件中。主要有有1000个观测数据，除去前面7个介绍消费者的编号、消费金额、支付方式、性别、是否是本地、收入、年龄变量之外，剩下还有11个商品的数据，这些数据主要介绍每个观测者是否购买这些商品。

本案例的重点在于分析商品之间的关联规则，主要是利用这后面11个商品的数据来进行分析，故在以下的分析中将数据前面7列删除。并且本次使用的数据中有每个列的观测值均是0和1，分别代表不购买、购买这些商品。这里我们需要将每个用户的观测数据进行转换，若在某一行观测数据中，某个字段（变量）的取值是1，则将这个字段名（变量）写入第一个观测值中，以下所有的观测值都这样处理。

基本原理介绍

基本概念：

$\mathcal{T}=i_1,i_2,...,i_m$表示所有项的集合。$\mathcal{T}$的子集称为项集。

关联规则的形式为$A\Rightarrow B$，$A,B$ 是两个项集，满足$A\cup B=\varnothing$, $A$和$B$分别 称为前项集和后项集。

项集的支持度：项集X的支持度support($X$)定义为数据集$D$的观测中包含X中所有项的比例。

关联规则的支持度：关联规则$A\Rightarrow B$的支持度confidence($A\Rightarrow B$)为数据集D的观测中同时包含$A$和$B$中所有项的比例，即support($A\cup B$).

关联规则的置信度：关联规则$A\Rightarrow B$的置信度confidence($A\Rightarrow B$)定义为数据集D中包含A的观测中同时包含$B$的比例，即support($A\Rightarrow B$)/support($A$)，这等价于给定A，B出现的条件概率。

在数据挖掘时，需要先指定最小支持度阈值(min_sup)和最小置信度(min_conf)。

强关联规则：支持度不小于min_sup且置信度不小于min_conf的关联规则。其中如果项集A满足最小支持度，那么$A\Rightarrow \varnothing$是强关联规则。

在此处，满足强关联规则条件的规则为好规则，这是评价一个规则好坏的一个标准。

Apriori算法

简介：Apriori寻找最有影响力的关联规则挖掘的算法。

步骤：

1. 找到所有频繁项集，那些support $\ge$ min_sup称为频繁项集。
2. 从频繁项集中生成所有强关联规则。

算法的性质：

1. 一个频繁项集的任何自己必然是频繁项集。
2. 一个非频繁项集的任何超集必然是非频繁项集。

对性质的举例子解释：

• 如果项集{A}是频繁的，则其子集{A, B}, {A, B,C}也是频繁的，因为A出现，则可以推出{A, B}和{A, B, C}也会出现。
• 同上，如果{A, B}不出现，说明{A}不出现，{B}也不出现。是性质1的逆否命题。

有意义的关联规则

解释关联规则挖掘的结果光有支持度和置信度是不够的，还需要考察当前关联规则的购买某件商品的提升值。其中关联规则$A\Rightarrow B$的提升值为：该规则的置信度与B的支持度的比例，即
$$\frac{p(\tilde{B}|\tilde{A})}{p(\tilde{B})}$$
在引入提升值之后，评价关联规则的好坏变成，支持度和置信度均不小于相应的最小阈值，且提升度大于1.

案例分析

首先读取数据，并且需要将数据转换成项集数据，将原始商品类数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6XfVml8g-1618494953333)(C:\Users\laguarange\AppData\Roaming\Typora\typora-user-images\image-20210331195814928.png)]

通过R语言的这种处理转变成每一行数据只有当前列名为1的那些列名，这些列表代表顾客购买的商品。

> inspect(shopBasket[1:4])
    items                           
[1] {confectionery,dairy,freshmeat} 
[2] {confectionery,freshmeat}       
[3] {beer,cannedveg,fish,frozenmeal}
[4] {dairy,wine} 

以上说明，第一个顾客购买了confectionery,dairy,freshmeat三件商品，第二个顾客购买了confectionery,freshmeat两件商品。

再查看商品篮数据的概览

> summary(shopBasket)
transactions as itemMatrix in sparse format with
 1000 rows (elements/itemsets/transactions) and
 11 columns (items) and a density of 0.2545455 

most frequent items:
 cannedveg frozenmeal   fruitveg       beer       fish    (Other) 
       303        302        299        293        292       1311 

element (itemset/transaction) length distribution:
sizes
  0   1   2   3   4   5   6   7   8 
 60 174 227 220 175  81  38  21   4 

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
    0.0     2.0     3.0     2.8     4.0     8.0 

includes extended item information - examples:
      labels
1       beer
2 cannedmeat
3  cannedveg

由上结果可以得知，数据中有1000个交易，所有购买的商品种类有11种。在一个1000*11的矩阵中，只有25.45455%个单元格有值，其它都是空的。同时也可得知，最常被购买的商品有cannedveg, frozenmeal fruitveg, beer, fish等5类商品。有4次交易同时购买了8种商品，购买商品的数量最少购买0件商品，最多一次性购买8件商品。

其中关于最频繁购买的商品的频率直方图如下：

在以上对数据格式进行预处理之后，使用Apriori算法进行数据之间的关联性分析。

由于在调用Apriori算法的时候，其中有一个sup_min，我们首先设置一个比较低的值，以查看大致的support的取值情况，根据这些结果再进一步选取更加合适的support_min的取值。

调整关联规则的sup_min和conf_min:

首先，固定conf_min=0.5(default)，这里取sup_min为0.01，查看大致的情况：

	Min	1st Qu	Median	Mean	3rd Qu	Max
support	0.01000	0.01200	0.01700	0.02923	0.03100	0.30300

使用summary(rules)得到Apriori算法分析的结果：

关联规则数为845有些多，因为实际中不需要这么多的关联规则，因此在这里我尝试将取值以上support的上三分位数0.031来作为新的支持度。

同理，固定sup_min，将conf_min设置为0.1查看得到上三分位数为0.5233。最终设置sup_min为0.031，设置conf_min为0.5233来作为后续的最小支持度和最小置信度，此时关联规则的数量为54条，大小合适。

最后得到强关联规则的前6条数据。如下所示，其中每条关联规则的支持度，置信度以及提升度都比较大。根据关联规则好坏的判别准则来讲，以下的关联规则均是在我们设置的规则下的强关联规则。

画图可视化最后得出强关联规则的支持度、置信度及提升度的分布：

可见，数据关联规则的置信度主要集中在上图的四个角，因此我们可以多加关注那些支持度、置信度以及提升度位于以上四角的商品。但是如果仅仅是在保证支持度和置信度的情况下，想要极大地提升关联规则的置信度的话，可以考虑将上方左右两角的商品放在一起。

总结反思

本案例主要分析了一下shop_basket.csv数据中顾客购买的商品之间的关联规则，调用R语言中的Apriori算法来分析这些关联规则，此处并没有考虑到之前所给出的顾客的消费金额以及收入等信息，这些仅仅是关联规则的初步分析。所以在以后的学习中，学习完了数据挖掘的建模算法之后，还需要回来将前7列的变量列入我们的分析范畴之内，以便挖掘出更加完整的信息。

此外，在进行选择min_sup和min_conf的时候，我个人仅凭借着自身的直觉判断了一下min_sup和min_conf的取值。仅仅从（1）强规则的个数。（2）设置一个比较低的min_sup和min_conf值，固定其中一个值查看min_sup的上三分位数（3）调节min_sup之后，再查看min_conf的上三分位数来作为最终的min_conf。这还没有参考到完善的数据挖掘理论，此处还需要进一步学习以改善。

最后画图分析查看强关联规则的支持度、可信度以及支持度的分布，更加清晰与直观。

学习其他同学的代码

1. 考虑前7列数据中所有变量的值，画图展示，并且在最后对其进行关联规则挖掘，发现年龄和消费额之间关联比较大。

2. 在挖掘出强关联规则之后，需要对得到的结果进行解释。

3. 也不删掉前7列的数据，对其进行分析。可以分别对男性和女性进行分析，指关联规则进行对比。缺点：男性和女性的比例是不一致的，所以需要考虑对比是否有意义？我自己的思考：可以尝试使用过采样来达到1：1的比例，且最开始在描述的时候需要将男性和女性数据之间的对比写出来。

   对比很重要的一点：需要有可比性，需要有控制变量。

参考

[1]薛薇.R语言数据挖掘[M] 北京:中国人民大学出版社.2016.324-339

[2]普拉迪帕塔 · 米什拉.R语言数据挖掘：实用项目解析[M] 北京:机械工业出版社.2017.112-121

[3] 关联规则transaction数据准备

[4] 【Python数据挖掘课程】八.关联规则挖掘及Apriori实现购物推荐

[5] 关联分析(3):Apriori R语言实现

代码

library(arules)
library(arulesViz)

# ----------1 读取数据
setwd("D:/lagua/CODING/R-learn/R-code/Chap4_AssociationRule")
shopBasket = read.csv("shop_basket.csv", sep=",")
# 去除前7个与购买商品无关的数据
shopBasket = shopBasket[, -seq(1, 7, 1)]

# ----------2 查看数据、转换数据、画图查看
# ----------2 查看数据
# 查看前4个观测数据顾客购买的商品
# 等价于inspect(shopBasket[1:4])
for (i in 1:4){
  print(names(shopBasket[i,])[shopBasket[i,]==1])
}

# ----------2 转换数据
# 将数据每一行字段取值为1的列名拿出来，这些列名代表每一条观测购买的商品
shopBasket <- apply(shopBasket,1,function(x) names(x)[x==1])
# 或者直接list(shopBasket)
# 再shopBaseket = as(shopBasket, "transactions")
# 转换成Apriori可以识别的数据类型
shopBasket = as(shopBasket, "transactions")

# 查看的概览
summary(shopBasket)
inspect(shopBasket[1:4])

# ----------2 画图查看
help("itemFrequencyPlot")
itemFrequencyPlot(shopBasket, support=0.01, 
                  main="Relative Itemeq Plot",
                  type="absolute")


# ----------3 关联分析 调整sup_min, conf_min
# 关联分析 初步分析
help(apriori)
rules <- apriori(shopBasket, 
                 parameter=list(support=0.01, confidence=0.1,target="rules"))
summary(rules)

# 固定min_conf 设置support为0.031（上三分位数）
rules <- apriori(shopBasket, 
                 parameter=list(support=0.031, confidence=0.1,target="rules"))
summary(rules)

# 调整min_sup之后并固定 设置confidence为0.5233（上三分位数）
rules <- apriori(shopBasket, 
                 parameter=list(support=0.031, confidence=0.5233,target="rules"))
summary(rules)


# ----------4 查看关联规则，按照support, confidence, lift排序
# 把所有规则按照lift（提升度）排序查看关联规则
shopBasket.sorted<-sort(x=rules,by="lift",decreasing=TRUE)
inspect(shopBasket.sorted)

# 逐条查看数据集shopBasket.sorted的前6条记录
# 这其实跟前面排序是等价的
inspect(head(shopBasket.sorted))

# 查看分析结果
options(digits=4)
#设置输出小数位数为4位数
inspect(head(rules,by="lift"))
# inspect函数逐条查看关联规则
#  by="lift"指定按提升值降序排列。


# ----------5 关联分析结果可视化
plot(rules)
# 对关联规则的支持度、置信度和提升值进行可视化


的前6条记录
# 这其实跟前面排序是等价的
inspect(head(shopBasket.sorted))

# 查看分析结果
options(digits=4)
#设置输出小数位数为4位数
inspect(head(rules,by="lift"))
# inspect函数逐条查看关联规则
#  by="lift"指定按提升值降序排列。


# ----------5 关联分析结果可视化
plot(rules)
# 对关联规则的支持度、置信度和提升值进行可视化

关联规则是从庞大的数据中提取一系列变量或因子间关系，以探索数据的变量或项目间隐含的关系。

1、基本原理

关联规则通常用支持度、置信度、增益三个指标来分别表示其显著性、正确性和价值。通过给性最小支持度、最小置信度作为门槛值。若该规则的支持度与置信度大于门槛值，则说明该规则有助于进行推论；若该规则的增益大于1，则说明其发生的条件概率有比原先的概率提高，即该规则有效。

1.1 支持度

支持度计算公式如下：

支持度 = P(X∩Y)

以下表中的数据为例。

交易记录	牛奶	面包	饼干	橙汁	汽水	泡面	水果
201701101	1	1	1	1	0	0	0
201701102	0	1	1	0	1	1	0
201701103	1	0	1	0	0	0	1
201701104	1	1	0	1	0	1	1
201701105	0	0	1	0	1	0	1

 

要了解顾客同时购买牛奶和面包的规则是否具有显著性，可以通过支持度衡量，即计算顾客同时购买牛奶和面包的概率：

P(面包∩牛奶) = 2/5 = 0.4

1.2 置信度

置信度是衡量一个事件发生的情况下，另一个事件发生的条件概率，即P(Y|X)。

P(Y|X)= P(X∩Y)/P(X)

一般情况下，置信度需要大于0.5。

 

如果想要了解规则“顾客在购买牛奶后也会购买面包”的信心程度，则可以用置信度：

P(面包|牛奶) = P(面包∩牛奶) / P(牛奶) = 0.4/0.6 = 0.67

1.3 增益

增益用于比较置信度与事件Y单独发生两者之间的概率。增益至少要大于1，才能说明事件X对事件Y的发生有促进作用。

lift= P(Y|X)/P(Y) = P(X∩Y)/[P(X)P(Y)]

规则“顾客在购买牛奶后也会购买面包”的增益计算如下：

lift(牛奶 -> 面包) = P(面包|牛奶) / P(面包) = P(面包∩牛奶) / [P(牛奶)P(面包)] = 0.4/[0.6*0.6] = 1.11

2、关联规则的分类

2.1以规则中属性的类型分类

当关联规则中的属性都是布尔值得时候，称为布尔关联规则。上面我们讨论购买面包与牛奶的问题，是典型的布尔关联规则。

当所要描述的规则的属性值是数量的时候，则称为量化的关联规则。对于量化的关联规则，可以通过数值的区间划分和归类转化为布尔属性。

2.2以规则中的数据维度分类

若规则是针对单一维度的时候，称之为单一维度关联规则。如规则“顾客在购买牛奶后也会购买面包”。

若规则是针对两个或两个以上维度的，则称为多维度关联规则或复合关联规则。如规则“三十岁以上单身男性工程师会购买海外基金”。

2.3以规则中的层级分类

若规则属性或项目属于同一层级，则称为单一层级关联规则。如规则“顾客在购买牛奶后也会购买面包”。

若数据同时包含较低层级和较高层级的项目集集合，则应该建立层级树，然后进行关联规则分析。当较低层级的项目集合不易发现关联规则时，则可以升级为较高的层级，以发现较明显的关联规则。这种关联规则，可以称为多层级关联规则。

3、关联规则的算法

关联规则的算法主要由搜索方式、计算项目及支持度组成。

3.1Apriori算法

Apriori算法是挖掘高频项目及的布尔值关联规则中最具代表性的算法，随后发展的关联规则算法大都以其为基础。该算法在大量的数据集中，利用项目集来建立关联规则，并计算每一个候选项目出现的次数，依据所设定的最小支持度为门槛，来衡量候选项目的关联规则是否显著。

Apriori算法分为5步：

（1）设定k = 1。快速扫描事务数据库，找出所有的1-项目集，与所规定的最小支持度门槛比较，高于最小支持度门槛的作为高频1-项目集，记为L₁。

（2）设定k = k + 1并产生新的候选k-项目集。删除候选k-项目集中所有k-1子项目集不属于L₁的候选项目集，并将过滤之后的k-项目集记为C_k。

（3）计算C_k中项目集各自的支持度S是否大于或等于规定的最小支持度，得到高频k-项目集。

（4）判定是否已搜索过所有的候选项目集，若已搜索完所有可能的候选集，则继续步骤（5）；否则，回到步骤（2）。

（5）计算所搜索项目集的置信度和增益，找出显著性的关联规则以帮助决策者指定相关决策。

Apriori算法的缺点是逐层扩展候选项目集必须大量地重复搜索数据库，因此当高频项目集长度较长或者数量较多时，必须花费较长时间来挑选产生候选项目集。

3.2Partition算法

为改善Apriori算法搜索效率不高的问题，Partition算法将数据库D分割成许多区段P_i，然连后进行扫描找出高频项目集，以建立显著关联规则。具体步骤为：

（1）将数据库分成互不相交的区段。分别计算各区段的相关项目集合支持度，找出各区段的高频项目集，称为区域高频项目集。每次读取一个分割区段P_i，采用Apriori算法找出区域高频项目集集合，记为L_Pi。

（2）取所有区域高频项目集的并集，即{L_P1∪L_P2∪…∪L_Pn}，作为D的整体候选项目集集合。对D重新计算该候选项目集的支持度，找出真正的高频项目集。

Partition算法的优点是大幅提高了搜索效率，缺点是在各区段产生了太多的非相关项目集时，需要大量的存储空间。

3.3 DHP算法

DHP算法利用散列树的构建，设计一个散列函数，将数据库中的项目集对应到散列表中，以累计各散列阶层所包含项目集的个数，并以累计的阶层数粗略估算候选项目集的支持度，以提前删除不可能称为高频项目集的候选项目集。具体步骤如下：

（1）设定k = 1。规定支持度与置信度的门槛值，搜索整个数据库D，找出高频1-项目集L₁，并建立2-项目集的散列表，记为H₂。

（2）设定k = k + 1；利用L_k-1产生项目集集合C_k，先用散列表中各阶层的累积次数对C_k进行初步筛选，在计算筛选后的各k-项目集支持度以决定高频项目集集合L_k。

（3）不断地重复上一步骤，知道所有高频项目集合L_k都无法再往上一阶层产生C_k+1。

DHP算法可以免除大量不必要的低阶层（特别是第二阶层）候选项目集筛选。其缺点是一开始必须花一些时间来建立散列表，且会导致初期有较高的误判率。

3.4 MSApriori算法

MSApriori算法中，关联规则最小支持度为该规则内所有项目集对应的最小支持度的最小值。分析者可以对具有较高价值的项目规定较低的支持度门槛，对价值较低的项目规定较高的支持度门槛。具体步骤如下：

（1）规定个项目的最小支持度门槛（MIS），并将所有项目按MIS递增排列。

（2）扫描所有的项目，找出符合最小支持度的候选1-项目集，记为F₁，并筛选F₁得到高频1-项目集L₁。其中F₁中的项目支持度都在min{MIS}以上，而L₁中的项目都在各自的最小支持度以上。

（3）产生其他候选项目集，方法与Apriori算法类似，以递归方式找出各阶层的候选项目集以及高频项目集。

3.5FP-Growth算法

繁殖模式增长（FP-Growth）算法是目前最有效率的关联规则算法。该算法将数据库内含有的频繁项目集压缩到一颗频繁模式树种，并保留项目集之间的重要关联信息。次方法在挖掘时不需要产生大量的候选项目集，最多只需扫描数据库两次，因此可大量减少IO时间，于单一维度及布尔值的领域中，都能以相当有效率的搜索方式建立关联规则。FP-Growth算法可以分为两个阶段：

（1）建立FP-tree

i) 第一次扫描数据库，找出符合最小支持度的第一阶高频项目集L₁ = {{A}，{B}，{C}，{F}}，依照支持度大小降序排列。得到的结果如下表所示：

交易记录	项目	属于高频项目集并按支持度大小排序
10001	A, B, D, E, F, G	{B}, {A}, {F}
10002	B, C, D, F	{B}, {C}, {F}
10003	A, B, C, F	{B}, {A}, {C}, {F}
10004	A, B, C, G	{B}, {A}, {C}

ii)建立FP-tree的根节点，表示为空节点，然后再次扫描数据库，将属于高频项目集的交易记录按步骤（1）所排列的项目顺序加入FP-tree中，直至所有高频项目集均经过扫描且建立连接关系，完成第二次扫描数据库的步骤。

iii) 为使得FP-tree更容易解读，建立项目连接表，使每个项目可通过一个节点链指出该叶节点在树种出现的位置，使树形图更为清晰。

（2）以FP-Growth算法针对该树中所隐含的规则进行挖掘。

i) 由项目连接表中的项目栏自下而上按照叶节点X坐落的顺序挖掘，按照每个关联项目连接FP-tree，找出FP-tree中X叶节点的前缀路径，而X叶节点的前缀路径所构建的FP-tree即为X的条件频繁模式树（简称X的条件FP-tree）。

ii) 以相同的方法递归挖掘X的条件FP-tree，计算模式库中每个项目的支持度，找出非空集合且具有高频项目集特征的项目集合，用模式库中的高频项目与X组合成高频项目集，列于候选项目集中。

iii) 运用阶段一与阶段二的模式不断对FP-tree递归挖掘，找出包含该叶节点的所有前缀路径，直到所有的叶节点均不存在任何前缀路径。

项目集	前缀路径	挖掘出的高频项目集
{F}	({B}{A}{C}) ({B}{A}) ({B}{C})	{F} {B, F}
{C}	({B}{A}) ({B})	{C} {B,C}
{A}	({B})	{A} {B,A}
{B}	ø	{B}

 

4、关联规则的应用

以arules包中的IncomeESL数据为例，开展关联规则分析。

> IncomeESL <- IncomeESL[complete.cases(IncomeESL),] #删除包含缺失值的数据
> dim(IncomeESL) #查看删除缺失值之后的IncomeESL的数据维度
[1] 6876   14
> IncomeESL.tr <- as(IncomeESL, "transactions") #关联规则分析必须使用transactions格式的数据，因此采用as()将data.frame数据转换为transactions对象
> rules <- apriori(IncomeESL.tr, parameter = list(support = 0.1, confidence = 0.6)) #采用Apriori算法进行关联规则分析，将支持度设为0.1、置信度设为0.6
Apriori

Parameter specification:
 confidence minval smax arem  aval originalSupport maxtime support minlen maxlen target   ext
        0.6    0.1    1 none FALSE            TRUE       5     0.1      1     10  rules FALSE

Algorithmic control:
 filter tree heap memopt load sort verbose
    0.1 TRUE TRUE  FALSE TRUE    2    TRUE

Absolute minimum support count: 687 

set item appearances ...[0 item(s)] done [0.00s].
set transactions ...[84 item(s), 6876 transaction(s)] done [0.00s].
sorting and recoding items ... [42 item(s)] done [0.00s].
creating transaction tree ... done [0.00s].
checking subsets of size 1 2 3 4 5 6 done [0.02s].
writing ... [2360 rule(s)] done [0.00s].
creating S4 object  ... done [0.00s].
> plot(rules) #绘制关联规则的散点图

这幅散点图表示了规则的分布图：大部分规则的support在0.2以内，Confidence在0.6-1内。每个点的颜色深浅代表了lift的值。

> plot(rules, method = "grouped")#绘制关联规则的群组矩阵图

群组矩阵图可以总览产生的关联规则中包含哪些项目，进而选取用户可能感兴趣的规则进行详细检查。右侧纵向列出的是规则的结果项目（RHS），上方横向列出的是规则的条件项目（LHS）；矩阵交汇的地方，以圆圈大小表示支持度，以颜色深浅代表增益。

比如我们选取的比较感兴趣的问题是“什么样的人会拥有自己的房子”，就可以通过筛选RHS为“householder status=own”（注意编写程序的时候，“=”两侧一定不能有空格，否则会提示错误）的显著（lift>1）规则，并列出其中支持度最大的5名做进一步分分析。

> rulesOwn <- subset(rules, subset = rhs %in% "householder status=own" & lift > 1) #遴选出RHS为{householder status=own}的显著（增益>1)规则
> inspect(head(sort(rulesOwn, by = "support"), n = 5)) #列出其中支持度排前5的规则做进一步分析
    lhs                              rhs                        support confidence     lift count
[1] {marital status=married}      => {householder status=own} 0.2614892  0.6779789 1.804096  1798
[2] {marital status=married,                                                                     
     language in home=english}    => {householder status=own} 0.2472368  0.6961507 1.852451  1700
[3] {marital status=married,                                                                     
     type of home=house}          => {householder status=own} 0.2329843  0.8279070 2.203053  1602
[4] {marital status=married,                                                                     
     type of home=house,                                                                         
     language in home=english}    => {householder status=own} 0.2207679  0.8433333 2.244102  1518
[5] {marital status=married,                                                                     
     ethnic classification=white} => {householder status=own} 0.2049156  0.7353862 1.956856  1409

可以发现，支持度前5名的规则中，所有的条件均包含“maritalstatus=married”，且其单一条件的置信度达到了0.68。

如果我们感兴趣的项目并未产生相应的规则，除了降低产生关联规则的门槛值以外，我们也可以通过对数据重新整合，降低属性的水平数后再进行关联规则分析。例如，本案例中，我们对高收入人群感兴趣，但产生的规则中却很少有与income相关的规则。那么，我们可以将income取值中原有的9个水平按照$40000为分界点重新划分为“$40-”、“$40+”两个水平，再次进行关联规则分析。

> library(arules) #加载arules程序包
> library(arulesViz) #加载arulesViz程序包
> data("IncomeESL") #加载数据文件IncomeESL
> class(IncomeESL) #查看IncomeESL的数据类型
[1] "data.frame"
> dim(IncomeESL) #查看IncomeESL的维度
[1] 8993   14
> IncomeESL <- IncomeESL[complete.cases(IncomeESL),] #删除包含缺失值的数据
> dim(IncomeESL) #查看删除缺失值之后的IncomeESL的数据维度
[1] 6876   14
> IncomeESL[["income"]] <- factor((as.numeric(IncomeESL[["income"]]) > 6) + 1, levels = 1:2, labels = c("$40-", "$40+")) #将income划分为2个水平
> IncomeESL.tr <- as(IncomeESL, "transactions") #关联规则分析必须使用transactions格式的数据，因此采用as()将data.frame数据转换为transactions对象
> rules <- apriori(IncomeESL.tr, parameter = list(support = 0.2, confidence = 0.6)) #采用Apriori算法进行关联规则分析，将支持度设为0.2、置信度设为0.6
Apriori

Parameter specification:
 confidence minval smax arem  aval originalSupport maxtime support minlen maxlen target   ext
        0.6    0.1    1 none FALSE            TRUE       5     0.2      1     10  rules FALSE

Algorithmic control:
 filter tree heap memopt load sort verbose
    0.1 TRUE TRUE  FALSE TRUE    2    TRUE

Absolute minimum support count: 1375 

set item appearances ...[0 item(s)] done [0.00s].
set transactions ...[77 item(s), 6876 transaction(s)] done [0.01s].
sorting and recoding items ... [23 item(s)] done [0.00s].
creating transaction tree ... done [0.00s].
checking subsets of size 1 2 3 4 5 done [0.01s].
writing ... [513 rule(s)] done [0.00s].
creating S4 object  ... done [0.00s].
> rulesIncome <- subset(rules, subset = rhs %in% "income=$40+" & lift > 1) #遴选出RHS为{householder status=own}的显著（增益>1)规则
> inspect(head(sort(rulesIncome, by = "support"), n = 5)) #列出其中支持度排前5的规则做进一步分析
    lhs                                                  rhs           support   confidence lift    
[1] {householder status=own}                          => {income=$40+} 0.2436009 0.6482198  1.716934
[2] {marital status=married}                          => {income=$40+} 0.2370564 0.6146305  1.627966
[3] {householder status=own,language in home=english} => {income=$40+} 0.2325480 0.6555966  1.736472
[4] {marital status=married,language in home=english} => {income=$40+} 0.2248400 0.6330876  1.676853
[5] {householder status=own,type of home=house}       => {income=$40+} 0.2107330 0.6665133  1.765387
    count
[1] 1675 
[2] 1630 
[3] 1599 
[4] 1546 
[5] 1449 

可以发现，“拥有自己的房子”和“已婚人士”为高收入人群的机会比较高置信度在0.6~0.7之间。

Python介绍、 Unix & Linux & Window & Mac 平台安装更新 Python3 及VSCode下Python环境配置配置
python基础知识及数据分析工具安装及简单使用(Numpy/Scipy/Matplotlib/Pandas/StatsModels/Scikit-Learn/Keras/Gensim))
数据探索（数据清洗）①——数据质量分析（对数据中的缺失值、异常值和一致性进行分析）
数据探索（数据清洗）②—Python对数据中的缺失值、异常值和一致性进行处理
数据探索（数据集成、数据变换、数据规约）③—Python对数据规范化、数据离散化、属性构造、主成分分析 降维
数据探索（数据特征分析）④—Python分布分析、对比分析、统计量分析、期性分析、贡献度分析、相关性分析
挖掘建模①—分类与预测
挖掘建模②—Python实现预测
挖掘建模③—聚类分析(包括相关性分析、雷达图等)及python实现
挖掘建模④—关联规则及Apriori算法案例与python实现
挖掘建模⑤—因子分析与python实现

关联规则

关联规则分析是数据挖掘中最活跃的研究方法之一，目的是在一个数据集中找出各项之间的关联关系，而这种关系并没有在数据中直接表示出来。

常用关联算法

Apriori算法

Apriori算法是最经典的挖掘频繁项集的算法，第一次实现了在大数据集上可行的关联规则提取，其核心思想是通过连接产生候选项与其支持度然后通过剪枝生成频繁项集。

关联规则和频繁项集

Apriori算法实现

Apriori算法的思想

Apriori算法的主要思想是找出存在于事务数据集中的最大的频繁项集，在利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。

Apriori算法的性质

频繁项集的所有非空子集也必须是频繁项集。
根据该性质可以得出：向不是频繁项集 I 的项集中添加事务A，新的项集
一定也不是频繁项集。

Apriori算法的实现的两个过程

• 过程一：找出所有的频繁项集。

  在这个过程中连接步和剪枝步互相融合，最终得到最大频繁项集 。

  1. 连接步：连接步的目的是找到K项集。
     

  2. 剪枝步：剪枝步紧接着连接步，在产生候选项
     的过程中起到减小搜索空间的目的。
     

由过程一可知未超过预定的最小支持度阈值的项集已被剔除，如果剩下这些规则又满足了预定的最小置信度阈值，那么就挖掘出了强关联规则。

算法案例及python实现

以超市销售数据为例，提取关联规则的最大困难在于当存在很多商品时，可能的商品的组合（规则的前项与后项）的数目会达到一种令人望而却步的程度。因而各种关联规则分析的算法从不同方面入手减小可能的搜索空间的大小以及减小扫描数据的次数。

首先将上表中的事务数据（一种特殊类型的记录数据）整理成关联规则模型所需的数据结构。从中抽取10个点餐订单作为事务数据集为方便起见将菜品{18491，8842，8693，7794，8705}分别简记为{a，b，c，d，e}），如：

menu_orders.xls

设支持度为0.2，即支持度计数为2，算法过程如下图：

设置最小支持度0.2，最小置信度0.5

apriori_rules.xls
c—a 表示c发生能够推出a发生，置信度为71.4286%，支持度为50%。
就第一条输出结果进行解释：客户同时点菜品c和a的概率是50%，点了菜品c ，再点菜品a的概率是71.4286%。知道了这些，就可以对顾客进行智能推荐，增加销量同时满足客户需求。

import pandas as pd

#自定义连接函数，用于实现L_{k-1}到C_k的连接
def connect_string(x, ms):
  x = list(map(lambda i:sorted(i.split(ms)), x))
  l = len(x[0])
  r = []
  for i in range(len(x)):
    for j in range(i,len(x)):
      if x[i][:l-1] == x[j][:l-1] and x[i][l-1] != x[j][l-1]:
        r.append(x[i][:l-1]+sorted([x[j][l-1],x[i][l-1]]))
  return r

#寻找关联规则的函数
def find_rule(d, support, confidence, ms = u'--'):
  result = pd.DataFrame(index=['support', 'confidence']) #定义输出结果
  
  support_series = 1.0*d.sum()/len(d) #支持度序列
  column = list(support_series[support_series > support].index) #初步根据支持度筛选
  k = 0
  
  while len(column) > 1:
    k = k+1
    print(u'\n正在进行第%s次搜索...' %k)
    column = connect_string(column, ms)
    print(u'数目：%s...' %len(column))
    sf = lambda i: d[i].prod(axis=1, numeric_only = True) #新一批支持度的计算函数
    
    #创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
    d_2 = pd.DataFrame(list(map(sf,column)), index = [ms.join(i) for i in column]).T
    
    support_series_2 = 1.0*d_2[[ms.join(i) for i in column]].sum()/len(d) #计算连接后的支持度
    column = list(support_series_2[support_series_2 > support].index) #新一轮支持度筛选
    support_series = support_series.append(support_series_2)
    column2 = []
    
    for i in column: #遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
      i = i.split(ms)
      for j in range(len(i)):
        column2.append(i[:j]+i[j+1:]+i[j:j+1])
    
    cofidence_series = pd.Series(index=[ms.join(i) for i in column2]) #定义置信度序列
 
    for i in column2: #计算置信度序列
      cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))]/support_series[ms.join(i[:len(i)-1])]
    
    for i in cofidence_series[cofidence_series > confidence].index: #置信度筛选
      result[i] = 0.0
      result[i]['confidence'] = cofidence_series[i]
      result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
  
  result = result.sort_index(ascending = False) #结果整理，输出
  print(u'\n结果为：')
  print(result)
  
  return result




inputfile = 'data/menu_orders.xls'
outputfile = 'tmp/apriori_rules.xls' #结果文件
data = pd.read_excel(inputfile, header = None)

print(u'\n转换原始数据至0-1矩阵...')
ct = lambda x : pd.Series(1, index = x[pd.notnull(x)]) #转换0-1矩阵的过渡函数，非空值转换成‘1’

b = map(ct, data.values) #用map方式执行
data = pd.DataFrame(list(b)).fillna(0) #实现矩阵转换，空值用0填充
print(u'\n转换完毕。')
del b #删除中间变量b，节省内存

support = 0.2 #最小支持度
confidence = 0.5 #最小置信度
ms = '---' #连接符，默认'--'，用来区分不同元素，如A--B。需要保证原始表格中不含有该字符

find_rule(data, support, confidence, ms).to_excel(outputfile) #保存结果