关联规则算法Apriori的学习与实现
关联规则算法Apriori的学习与实现
(2011-07-18 11:28:52)
首先我们来看，什么是规则？规则形如”如果…那么…(If…Then…)”,前者为条件，后者为结果。关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。例如购物篮分析。牛奶?面包[支持度：3%，置信度：40%] 支持度3%意味3%顾客同时购买牛奶和面包。置信度40%意味购买牛奶的顾客40%也购买面包。规则的支持度和置信度是两个规则兴趣度度量，它们分别反映发现规则的有用性和确定性。关联规则是有趣的，如果它满足最小支持度阈值和最小置信度阈值。这些阈值可以由用户或领域专家设定。
我们先来认识几个相关的定义：
定义1：支持度（support）
支持度s是事务数据库D中包含A U B的事务百分比，它是概率P（A U B），即support （A B）=P（A U B），它描述了A和B这两个物品集的并集在所有的事务中出现的概率。定义2：置信度（confidence）
可信度为事务数据库D中包含A的事务中同时也包含B的百分比，它是概率P（B|A），即confidence（A B）=P（B|A）。
定义3：频繁项目集
支持度不小于用户给定的最小支持度阈值（minsup）的项集称为频繁项目集（简称频集），或者大项目集。所有
的频繁1-项集记为L1。
假设有如下表的购买记录。
顾客项目
1orange juice, coke
2milk, orange juice, window cleaner
3orange juice, detergent
4orange juice, detergent, coke
5window cleaner
将上表整理一下，得到如下的一个2维表
Orange Win Cl Milk Coke Detergent
Orange41122
WinCl12100
Milk11100
Coke20021
Detergent10002
上表中横栏和纵栏的数字表示同时购买这两种商品的交易条数。如购买有Orange的交易数为4，而同时购买Orange和Coke的交易数为2。
置信度表示了这条规则有多大程度上值得可信。设条件的项的集合为A,结果的集合为B。置信度计算在A中，同时也含有B的概率。即Confidence(A==>B)=P(B|A)。例如计算"如
果Orange则Coke"的置信度。由于在含有Orange的4条交易中，仅有2条交易含有Coke.其置信度为0.5。
支持度计算在所有的交易集中，既有A又有B的概率。例如在5条记录中，既有Orange 又有Coke的记录有2条。则此条规则的支持度为2/5=0.4。现在这条规则可表述为，如果一个顾客购买了Orange,则有50%的可能购买Coke。而这样的情况（即买了Orange会再买Coke）会有40%的可能发生。
再来考虑下述情况。
下面以迭代的方式找出频繁集。首先找出1-itemsets的频繁集，然后使用这个1-itemsets，进行组合，找出2-itemsets的频繁集。如此下去，直到不再满足最小支持度或置信度的条件为止。这其中重要的两步骤分别是连接(join)和剪枝(prune).即从(k-1)-itemsets中的项进行组合，产生备选集(Candidate itemsets)。再从备选集中，将不符合最小支持度或置信度的项删去。例如
==>L2:==>C3==>L3:
对于频繁集中的每一项k-itemset,可以产生非空子集，对每一个子集，可以得到满足最小置信度的规则了。例如考虑{I1,I2,I5}。其子集有{I1,I2}, {I1,I5}, {I2,I5}, {I1}, {I2}, {I5}。可以产生规则，{I1,I2}=>{I5} (50%), {I1,I5}=>{I2} (100%), {I2,I5}=>{I1}
(100%),{I1}=>{I2,I5} (33%), {I2}=>{I1,I5} (29%), {I5}=>{I1,I2} (100%)。
也不是每个数据集都有产生强规则。例如"Thinkpad notebook" 和"Canon printer"一起可能很难产生有效规则。因为恰好一起买这两个牌子的产品的顾客太少。但不妨将Thinkpad notebook放到Notebook这一层次上考虑，而Canon printer放到printer这一去层次上考虑。这样的话，一起买notebook和printer的顾客就较多了。也即Multilevel association rules。
自1994年由Agrawal等人提出的关联规则挖掘Apriori的算法从其产生到现在，对关联规则挖掘方面的研究有着很大的影响。Apriori 算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。算法基于这样的事实：算法使用频繁项集性质的先验知识。Apriori 使用一种称作逐层搜索的迭代方法，k-项集用于探索（k+1）-项集。首先，找出频繁1-项集的集合。该集合记作L1。L1用于找频繁2-项集的集合L2，而L2用于找L3，如此下去，直到不能找到频繁k-项集。找每个Lk需要一次数据库扫描。为提高频繁项集逐层产生的效率，一种称作Apriori 性质的重要性质用于压缩搜索空间。
为了提高频繁项目集逐层产生的效率，Apriori算法利用了两个重要的性质用于压缩搜索空间：
（l）若X是频繁项集，则x的所有子集都是频繁项集。
（2）若x是非频繁项集，则X的所有超集都是非频繁项集。
算法：Apriori算法，使用逐层迭代找出频繁项集。
输入：事务数据库D；最小支持度阈值min_sup。
输出：D 中的频繁项集L。
1）L1 = find_frequent_1_itemsets（D）；
2）for （k = 2；Lk-1 ≠；k++）{
3）Ck = aproiri_gen（Lk-1，min_sup）；
4）for each transaction t D{ //scan D for count
5）Ct = subset（Ck，t）；//get subsets of t that are candidates
6）for each candidate c Ct
7）c.count++；
8）}
9）Lk={c Ck | c.count ≥ min_sup}
10）}
11）return L = ∪kLk；
现举例说明：如表1所示为事务数据库D，设最小支持度为20%，挖掘频繁项集的具体过程如表１所示。
表1 事务数据库D
图１所示为Apriori算法挖掘频繁集的过程，其中最小支持度为20%。
图1 Apriori算法的执行流程
第一步，经过算法的第一次迭代，对事务数据库进行一次扫描，计算出D中所包含的每个项目出现的次数，生成候选1-项集的集合C1。
第二步，根据设定的最小支持度，从C1中确定频繁1-项集L1。
第三步，由L1产生候选2-项集C2，然后扫描事务数据库对C2中的项集进行计数。
第四步，根据最小支持度，从候选集C2中确定频繁集L2。
第五步，由频繁2-项集L2生成候选3-项集C3，生成的候选3-项集的集合C3={{1，2，3}，{1，3，5}，{2，3，5}}，根据Apriori的性质剪枝：所有的频繁项集的子集都是频繁的，项集{1，2，3}的子集{1，2}不包含在频繁2-项集L2中，故删除{1，2，3}。项集{1，3，5}的子集{1，5}也不包含在频繁2-项集L2中，故删除{1，3，5}，项集{2，3，5}的所有子集都是L2的元素，故保留。
Apriori算法的效率分析：
（1）Apriori性质能显著减少候选集的数目。事务数据库TDB总共有4个项目，因此可能的2-项集有=6个。正如本例所示，利用Apriori性质，我们只需要检查4个候选2-项集的支持度。Apriori算法在2项集这个层次上剪枝率达33.3%。随着候选集的长度逐渐增大，可能的组合数目也急剧增大，因此Apriori算法的剪枝效率也越来越高。
（2）尽管Apriori能对大量候选集剪枝，但是在大型的事务数据库中，仍然可能有大量的候选集需要处理，并且这种操作相当耗时。例如，如果事务数据库包含106个项目，并且只有1%（即104）的项目是频繁的，Apriori需要产生超过107个候选2-项集，扫描数据库计算它们的支持度，生成L2以产生候选3-项集。
（3）反复地扫描数据库、计算候选集的支持度，再生成新的长度加1的候选集，Apriori算法是冗长乏味的，尤其是当存在长模式的时候。Apriori是一种产生候选集，然后检测其支持度的算法。为挖掘频集X ={x1，x2…，x100} . Apriori需要扫描数据库100次。
针对Apriori算法存在的缺点，人们对Apriori算法进行了多方面的改进，希望能够找出一个高效、可靠的挖掘频繁项集的算法。这些算法大多是以Apriori 为核心，或是其变体，或是其扩展。如增量更新算法、并行算法等
下面是使用Java语言实现的Apriori算法，实现了AprioriAlgorithm 类，包含了频繁项集的挖掘过程和频繁关联规则的挖掘过程。
另外，有一个辅助类ProperSubsetCombination用于计算一个频繁项集的真子集，采用组合原理，基于数值编码原理实现的组合求解集合的真子集。
算法实现
（一）核心类
Apriori算法的核心实现类为AprioriAlgorithm，实现的Java代码如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class AprioriAlgorithm {
private Map
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事务数据库中的事务数
private Map
private Map
public AprioriAlgorithm(Map
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMap
assiciationRules = new HashMap
Set
}
public Map
Map
HashMap
Map
this.getCandFreq1ItemSet();
Iterator
candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry
// 计算支持度
Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supported>=minSup) {
freq1ItemSetMap.put(entry.getKey(), supported);
}
}
return freq1ItemSetMap;
}
public Map
Map
HashMap
Iterator
txDatabase.entrySet().iterator();
// 统计支持数，生成候选频繁1-项集
while(it.hasNext()) {
Map.Entry
Set
for(String item : itemSet) {
Set
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)) {
Integer value = 1;
candFreq1ItemSetMap.put(key, value);
}
else {
Integer value =
1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key, value);
}
}
}
return candFreq1ItemSetMap;
}
public Set
Iterator
Set
while(it.hasNext()) {
originalItemSet = it.next();
Iterator
while(itr.hasNext()) {
Set
identicalSet.addAll(originalItemSet);
Set
identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet 与set集合中公有的元素
if(identicalSet.size() == m-1) { // (k-1)-项集中k-2个相同
Set
differentSet.addAll(originalItemSet);
differentSet.removeAll(set); // 因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1
differentSet.addAll(set); // 构造候选k-项集的一个元素(set大小为k-1,differentSet大小为k)
candFreqKItemSet.add(differentSet); // 加入候选k-项集集合
}
}
}
return candFreqKItemSet;
}
private Iterator
Iterator
while(it.hasNext()) {
if(itemSet.equals(it.next())) {
break;
}
}
return it;
}
public Map
Map
// 调用aprioriGen方法，得到候选频繁k-项集
Set
// 扫描事务数据库
Iterator
// 统计支持数
while(it.hasNext()) {
Map.Entry
Iterator
while(kit.hasNext()) {
Set
Set
set.addAll(kSet);
set.removeAll(entry.getValue()); // 候选频繁k-项集与事务数据库中元素做差元算
if(set.isEmpty()) { // 如果拷贝set为空，支持数加1
if(candFreqKItemSetMap.get(kSet) == null) {
Integer value = 1;
candFreqKItemSetMap.put(kSet, value);