关联规则挖掘Apriori算法的实现

发表于

「这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战」

实验名称

关联规则挖掘Apriori算法的实现

实验目的

1.掌握频繁项目集的生成原理

2.掌握关联规则挖掘的原理

3.掌握在weka中进行关联规则挖掘的具体流程。

实验内容

1.根据给定的事务数据库，支持数阈值2和置信度阈值0.7，编写代码生成频繁项目集及对应的关联规则。

2.利用weka工具对天气数据、美国国会议员投票信息、超市购物篮数据进行关联规则挖掘，并分析挖掘结果

实验步骤及结果

一.根据给定的事务数据库，支持数阈值2和置信度阈值0.7，编写代码生成频繁项目集及对应的关联规则。

新建java项目 Apriori.java

1.事务数据库、支持数、置信度的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
java复制代码package rule;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Apriori {
	private final static int SUPPORT = 2;
	private final static String ITEM_SPLIT = ";";
	private final static String CON = "->";
	private final static double CONFIDENCE = 0.7;
	private final static List<String> transList = new ArrayList<String>();
	static {
		transList.add("1;2;5;");
		transList.add("2;4;");
		transList.add("2;3;");
		transList.add("1;2;4;");
		transList.add("1;3;");
		transList.add("2;3;");
		transList.add("1;3;");
		transList.add("1;2;3;5;");
		transList.add("1;2;3;");
	}

2.频繁项目集的生成过程，其中调用了方法getItem1FC( ),生成L1，递归调用getCandidateCollection()进行连接、剪枝生成C2、C3……，最后生成L2，L3……

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
java复制代码// 生成频繁项目集
	public Map<String, Integer> getFC() {
		// 声明哈希表，用来存放键值对，即项目和支持数对，所有的频繁集
		Map<String, Integer> frequentCollectionMap = new HashMap<String, Integer>();
		frequentCollectionMap.putAll(getItem1FC());
		Map<String, Integer> itemkFcMap = new HashMap<String, Integer>();
		itemkFcMap.putAll(getItem1FC());
		while (itemkFcMap != null && itemkFcMap.size() != 0) {
			Map<String, Integer> candidateCollection = getCandidateCollection(itemkFcMap);
			Set<String> ccKeySet = candidateCollection.keySet();

			// 对候选集项进行累加计数
			for (String trans : transList) {
				for (String candidate : ccKeySet) {
					boolean flag = true;// 用来判断交易中是否出现该候选项
					String[] candidateItems = candidate.split(ITEM_SPLIT);
					for (String candidateItem : candidateItems) {
						if (trans.indexOf(candidateItem + ITEM_SPLIT) == -1) {
							flag = false;
							break;
						}
					}
					if (flag) {
						Integer count = candidateCollection.get(candidate);
						candidateCollection.put(candidate, count + 1);
					}
				}
			}

			// 从候选集中找到符合支持度的频繁集项
			itemkFcMap.clear();
			for (String candidate : ccKeySet) {
				Integer count = candidateCollection.get(candidate);
				if (count >= SUPPORT) {
					itemkFcMap.put(candidate, count);
				}
			}
			frequentCollectionMap.putAll(itemkFcMap);
		}
		return frequentCollectionMap;
	}

3.根据Lk 进行连接、剪枝生成Ck+1(剪枝指对连接生成的c，判断它的k-子集是否属于Lk,不属于则剪枝去掉该c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
java复制代码private Map<String, Integer> getCandidateCollection(Map<String, Integer> itemkFcMap) {
		Map<String, Integer> candidateCollection = new HashMap<String, Integer>();
		Set<String> itemkSet1 = itemkFcMap.keySet();
		Set<String> itemkSet2 = itemkFcMap.keySet();
		for (String itemk1 : itemkSet1) {
			for (String itemk2 : itemkSet2) {
				String[] tmp1 = itemk1.split(ITEM_SPLIT);// 进行连接
				String[] tmp2 = itemk2.split(ITEM_SPLIT);
				String c = "";
				if (tmp1.length == 1) {
					if (tmp1[0].compareTo(tmp2[0]) < 0) {
						c = tmp1[0] + ITEM_SPLIT + tmp2[0] + ITEM_SPLIT;
					}
				} else {
					boolean flag = true;
					for (int i = 0; i < tmp1.length - 1; i++) {
						if (!tmp1[i].equals(tmp2[i])) {
							flag = false;
							break;
						}
					}
					if (flag && (tmp1[tmp1.length - 1].compareTo(tmp2[tmp2.length - 1]) < 0)) {
						c = itemk1 + tmp2[tmp2.length - 1] + ITEM_SPLIT;
					}
				}
				boolean hasInfrequentSubSet = false;// 进行剪枝
				if (!c.equals("")) {
					String[] tmpC = c.split(ITEM_SPLIT);
					for (int i = 0; i < tmpC.length; i++) {
						String subC = "";
						for (int j = 0; j < tmpC.length; j++) {
							if (i != j) {
								subC = subC + tmpC[j] + ITEM_SPLIT;
							}
						}
						if (itemkFcMap.get(subC) == null) {
							hasInfrequentSubSet = true;
							break;
						}
					}
				} else {
					hasInfrequentSubSet = true;
				}
				if (!hasInfrequentSubSet) {
					candidateCollection.put(c, 0);
				}
			}
		}
		return candidateCollection;
	}

4.L1的生成过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
java复制代码private Map<String, Integer> getItem1FC() {
		Map<String, Integer> sItem1FcMap = new HashMap<String, Integer>();// 存放候选1项集
		Map<String, Integer> rItem1FcMap = new HashMap<String, Integer>();// 存放频繁1项集
		for (String trans : transList) {
			String[] items = trans.split(ITEM_SPLIT);
			for (String item : items) {
				Integer count = sItem1FcMap.get(item + ITEM_SPLIT);
				if (count == null) {
					sItem1FcMap.put(item + ITEM_SPLIT, 1);
				} else {
					sItem1FcMap.put(item + ITEM_SPLIT, count + 1);
				}
			}
		}
		Set<String> keySet = sItem1FcMap.keySet();
		for (String key : keySet) {
			Integer count = sItem1FcMap.get(key);
			if (count >= SUPPORT) {
				rItem1FcMap.put(key, count);
			}
		}
		return rItem1FcMap;
	}

5. 生成关联规则的过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
java复制代码public Map<String, Double> getRelationRules(Map<String, Integer> frequentCollectionMap) {
		Map<String, Double> relationRules = new HashMap<String, Double>();
		Set<String> keySet = frequentCollectionMap.keySet();
		for (String key : keySet) {
			double countAll = frequentCollectionMap.get(key);
			String[] keyItems = key.split(ITEM_SPLIT);
			if (keyItems.length > 1) {
				List<String> source = new ArrayList<String>();
				Collections.addAll(source, keyItems);
				List<List<String>> result = new ArrayList<List<String>>();
				buildSubSet(source, result);// 获得source的所有非空子集
				for (List<String> itemList : result) {
					if (itemList.size() < source.size()) {// 只处理真子集
						List<String> otherList = new ArrayList<String>();
						for (String sourceItem : source) {
							if (!itemList.contains(sourceItem)) {
								otherList.add(sourceItem);
							}
						}
						String reasonStr = "";// 前置
						String resultStr = "";// 结果
						for (String item : itemList) {
							reasonStr = reasonStr + item + ITEM_SPLIT;
						}
						for (String item : otherList) {
							resultStr = resultStr + item + ITEM_SPLIT;
						}
						double countReason = frequentCollectionMap.get(reasonStr);
						double itemConfidence = countAll / countReason;// 计算置信度
						if (itemConfidence >= CONFIDENCE) {
							String rule = reasonStr + CON + resultStr;
							relationRules.put(rule, itemConfidence);
						}
					}
				}
			}
		}
		return relationRules;
	}

6.对频繁项目集的所有子集生成关联规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
java复制代码private void buildSubSet(List<String> sourceSet, List<List<String>> result) {
		// 仅有一个元素时，递归终止。此时非空子集仅为其自身，所以直接添加到result中
		if (sourceSet.size() == 1) {
			List<String> set = new ArrayList<String>();
			set.add(sourceSet.get(0));
			result.add(set);
		} else if (sourceSet.size() > 1) {
			// 当有n个元素时，递归求出前n-1个子集，在于result中
			buildSubSet(sourceSet.subList(0, sourceSet.size() - 1), result);
			int size = result.size();// 求出此时result的长度,用于后面的追加第n个元素时计数
			// 把第n个元素加入到集合中
			List<String> single = new ArrayList<String>();
			single.add(sourceSet.get(sourceSet.size() - 1));
			result.add(single);
			// 在保留前面的n-1子集的情况下，把第n个元素分别加到前n个子集中，并把新的集加入到result中;
			// 为保留原有n-1的子集，所以需要先对其进行复制
			List<String> clone;
			for (int i = 0; i < size; i++) {
				clone = new ArrayList<String>();
				for (String str : result.get(i)) {
					clone.add(str);
					clone.add(sourceSet.get(sourceSet.size() - 1));
					result.add(clone);
				}
			}
		}

	}

7.主函数，调用getFC()输出频繁项目集，调用getCandidateCollection()生成存在强关联规则的项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
java复制代码public static void main(String[] args) {
		Apriori apriori = new Apriori();
		Map<String, Integer> frequentCollectionMap = apriori.getFC();
		System.out.println("--------------频繁项目集"+"--------------");
		Set<String> fcKeySet = frequentCollectionMap.keySet();
		for (String fcKey:fcKeySet){
			System.out.println(fcKey+" : "+frequentCollectionMap.get(fcKey));
		}
		Map<String, Double> relationRulesMap = apriori.getRelationRules(frequentCollectionMap);
		System.out.println("--------------存在强关联规则如下"+"--------------");
		Set<String> rrKeySet=relationRulesMap.keySet();
		for(String rrKey:rrKeySet){
			System.out.println(rrKey+" : "+relationRulesMap.get(rrKey));
		}
	}
}

运行结果：

image.png

二.利用weka工具对天气数据、美国国会议员投票信息、超市购物篮数据进行关联规则挖掘，并分析挖掘结果

<1>

image.png

image.png

选择Apriori

image.png

设置好各项参数

image.png

image.png

设置完成后点击start运行

image.png

image.png

Run information //实验运行信息

Scheme: weka.associations.Apriori //所选的关联规则挖掘方案：Apriori算法

-N 10 -T 0 -C 0.9 -D 0.05 -U 1.0 -M 0. 1 -S -1.0 -c -1

//各参数依次表示：

I - 输出项集，若设为false则该值缺省;

N 10 - 规则数为10;

T 0 – 度量单位选为置信度，(T1-提升度，T2杠杆率，T3确信度);

C 0.9 – 度量的最小值为0.9;

D 0.05 - 递减迭代值为0.05;

U 1.0 - 最小支持度上界为1.0;

M 0.1 - 最小支持度下届设为0.1;

S -1.0 - 重要程度为-1.0;

c -1 - 类索引为-1输出项集设为真

Relation:weather.symbolic //数据的名称weather.symbolic

Instances: 14 //数据的记录数 14

Attributes:5 //属性数目 5以及各属性名称

Apriori // Apriori算法运行结果

Minimum support: 0. 1 5 (2 instances) //最小支持度0.15，即最少需要2个实例

Minimum metric : 0.9 //最小度量<置信度>: 0.9

Number of cycles performed: 1 7 //进行了17轮搜索

Generated sets of large itemsets: //生成的频繁项集

Size of set of large itemsets L(1): 12 //频繁1项集：12个

Size of set of large itemsets L( 2 ): 47 //频繁2项集：47个

Size of set of large itemsets L( 3 ): 39 //频繁3项集：39个

Size of set of large itemsets L( 4 ): 6 //频繁4项集：6个

Best rules found: //最佳关联规则

1. outlook=overcast 4 ==> play=yes 4 conf:(1) lift:(1.56) lev:(0.1) [1] conv:(1.43)

//规则采用“前件 num.1 ==>结论 num.2”的形式表示，前件后面的数字表示有多少个实例满足前件，结论后的数字表示有多少个实例满足整个规则，这就是规则的”支持度“。

conf：置信度 lift：提升度 lev：杠杠率 conv：确信度

设置参数 outputItemSets 为 true，再次运行 Apriori 算法，会生成各频繁项目集及他们的支

持数如下：

image.png

<2>加载 vote.arff 数据集，该数据集中各属性含义如下：

image.png

切换至 Associate 标签页，选择 Apriori 算法，保持默认选项，单击 start 按钮，

结果如下：

image.png

参数解释如<1>一致

<3>加载 supermarket.arff 数据集

image.png

运行 Apriori 算法，结果如下：

image.png

解析如下：

第一条规则：饼干+冷冻食品+水果+高总额 ==> 面包和蛋糕

第二条规则：烘烤所需+饼干+水果+高总额 ==> 面包和蛋糕

第三条规则：烘烤所需+冷冻食品+水果+高总额 ==> 面包和蛋糕

第四条规则：饼干+水果+蔬菜+高总额 ==> 面包和蛋糕

第五条规则：聚会零食+水果+高总额 ==> 面包和蛋糕

第六条规则：饼干+冷冻食品+蔬菜+高总额 ==> 面包和蛋糕

第七条规则：烘烤所需+饼干+蔬菜+高总额 ==> 面包和蛋糕

第八条规则：饼干+水果+高总额 ==> 面包和蛋糕

第九条规则：冷冻食品+水果+蔬菜+高总额 ==> 面包和蛋糕

第十条规则：冷冻食品+水果+高总额 ==> 面包和蛋糕

可以发现

  1. 购买饼干或冷冻食品 ，会购买水果或蔬菜 （水果 8 条规则，蔬菜 4条规则）
  1. 购买饼干、冷冻食品 、水果、蔬菜，会购买面包、蛋糕（多条）
  1. 购买上述食品的，采购量会很大（金额高）（9条）
  1. 采购量会很大（金额高）的，一般会购买面包、蛋糕（10条规则都包含这两项）

总结：

Apriori算法需要完全的标称型数据，如果有数值型属性，必须先进行离散化。关联规则挖掘发现大量数据中项集之间有趣的关联或者相互联系。关联规则挖掘的一个典型例子就是购物篮分析，该过程通过发现顾客放入其购物篮中不同商品之间的联系，分析出顾客的购买习惯，通过了解哪些商品频繁地被顾客同时买入，能够帮助零售商制定合理的营销策略。其可以揭示数据中隐藏的关联模式，帮助人们进行市场运作，决策支持等。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%