关联规则挖掘Apriori算法的实现
实验名称
关联规则挖掘Apriori算法的实现
实验目的
1.掌握频繁项目集的生成原理
2.掌握关联规则挖掘的原理
3.掌握在weka中进行关联规则挖掘的具体流程。
实验内容
1.根据给定的事务数据库,支持数阈值2和置信度阈值0.7,编写代码生成频繁项目集及对应的关联规则。
2.利用weka工具对天气数据、美国国会议员投票信息、超市购物篮数据进行关联规则挖掘,并分析挖掘结果
实验步骤及结果
一.根据给定的事务数据库,支持数阈值2和置信度阈值0.7,编写代码生成频繁项目集及对应的关联规则。
新建java项目 Apriori.java
1.事务数据库、支持数、置信度的定义
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……
// 生成频繁项目集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)
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的生成过程
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. 生成关联规则的过程
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.对频繁项目集的所有子集生成关联规则
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()生成存在强关联规则的项目
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));}}
}复制代码
运行结果:
二.利用weka工具对天气数据、美国国会议员投票信息、超市购物篮数据进行关联规则挖掘,并分析挖掘结果
<1>
选择Apriori
设置好各项参数
设置完成后点击start运行
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 算法,会生成各频繁项目集及他们的支
持数如下:
<2>加载 vote.arff 数据集,该数据集中各属性含义如下:
切换至 Associate 标签页,选择 Apriori 算法,保持默认选项,单击 start 按钮,
结果如下:
参数解释如<1>一致
<3>加载 supermarket.arff 数据集
运行 Apriori 算法,结果如下:
解析如下:
第一条规则:饼干+冷冻食品+水果+高总额 ==> 面包和蛋糕
第二条规则:烘烤所需+饼干+水果+高总额 ==> 面包和蛋糕
第三条规则:烘烤所需+冷冻食品+水果+高总额 ==> 面包和蛋糕
第四条规则:饼干+水果+蔬菜+高总额 ==> 面包和蛋糕
第五条规则:聚会零食+水果+高总额 ==> 面包和蛋糕
第六条规则:饼干+冷冻食品+蔬菜+高总额 ==> 面包和蛋糕
第七条规则:烘烤所需+饼干+蔬菜+高总额 ==> 面包和蛋糕
第八条规则:饼干+水果+高总额 ==> 面包和蛋糕
第九条规则:冷冻食品+水果+蔬菜+高总额 ==> 面包和蛋糕
第十条规则:冷冻食品+水果+高总额 ==> 面包和蛋糕
可以发现
1. 购买饼干或冷冻食品 ,会购买水果或蔬菜 (水果 8 条规则,蔬菜 4条规则)
2. 购买饼干、冷冻食品 、水果、蔬菜,会购买面包、蛋糕(多条)
3. 购买上述食品的,采购量会很大(金额高)(9条)
4. 采购量会很大(金额高)的,一般会购买面包、蛋糕(10条规则都包含这两项)
总结:
Apriori算法需要完全的标称型数据,如果有数值型属性,必须先进行离散化。关联规则挖掘发现大量数据中项集之间有趣的关联或者相互联系。关联规则挖掘的一个典型例子就是购物篮分析,该过程通过发现顾客放入其购物篮中不同商品之间的联系,分析出顾客的购买习惯,通过了解哪些商品频繁地被顾客同时买入,能够帮助零售商制定合理的营销策略。其可以揭示数据中隐藏的关联模式,帮助人们进行市场运作,决策支持等。
关联规则挖掘Apriori算法的实现相关推荐
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( Apriori 算法过程 | Apriori 算法示例 )
文章目录 一. Apriori 算法过程 二. Apriori 算法示例 参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 Transaction ...
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( 关联规则性质 | 非频繁项集超集性质 | 频繁项集子集性质 | 项集与超集支持度性质 )
文章目录 一. 非频繁项集超集性质 二. 频繁项集子集性质 三. 项集与超集支持度性质 参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 Trans ...
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( 频繁项集 | 非频繁项集 | 强关联规则 | 弱关联规则 | 发现关联规则 )
文章目录 一. 频繁项集 二. 非频繁项集 三. 强关联规则 四. 弱关联规则 五. 发现关联规则 参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 ...
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( 关联规则 | 数据项支持度 | 关联规则支持度 )
文章目录 一. 关联规则 二. 数据项支持度 三. 关联规则支持度 参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 Transaction 概念 ...
- 数据分享|R语言关联规则挖掘apriori算法挖掘评估汽车性能数据
全文链接:http://tecdat.cn/?p=32092 我们一般把一件事情发生,对另一件事情也会产生影响的关系叫做关联.而关联分析就是在大量数据中发现项集之间有趣的关联和相关联系(形如" ...
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( 置信度 | 置信度示例 )
文章目录 一. 置信度 二. 置信度 示例 参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 Transaction 概念 | 项 Item 概念 ...
- 关联规则挖掘--Apriori算法
关联规则挖掘--Apriori算法 1.关联规则概述 2.置信度.支持度.提升度的概念 3.关联规则挖掘问题 4.Apriori算法 4.1 算法步骤 4.2 先验原理 4.3 寻找最大频繁项的过程 ...
- 【数据挖掘】关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集 与 事物 Transaction 概念 | 项 Item 概念 | 项集 Item Set | 频繁项集 | 示例解析 )
文章目录 一. 关联规则挖掘简介 二. 数据集 与 事物 ( Transaction ) 概念 三.项 ( Item ) 概念 四.项集 ( Item Set ) 概念 五.频繁项集 六.数据集.事物 ...
- 关联规则挖掘——Apriori算法的基本原理以及改进
问题引入 关联规则挖掘发现大量数据中项集之间有趣的关联或者相互联系.关联规则挖掘的一个典型例子就是购物篮分析,该过程通过发现顾客放入其购物篮中不同商品之间的联系,分析出顾客的购买习惯,通过了解哪些商品 ...
最新文章
- OpenGL中不可以有两个以上myDisplay函数,在主函数中生效的是最后调用的那个
- C++深复制(深拷贝)、浅复制(浅拷贝)和复制构造函数(拷贝构造函数)详解+实例
- vue工程全局设置ajax的等待动效
- c语言凸包算法,基于C语言的凸包算法实现
- 恒生估值系统_恒生指数和恒生国企指数投资价值分析
- MySQL5.6忘记root用户名和密码
- 夏日清凉小风扇网站源码 抖音引流神器
- shell的if和else
- matlab曲线拟合的应用,MATLAB软件在曲线拟合中的应用
- linux高级知识,LAMP架构(一),MYSQL安装
- 概率论与数理统计【三】一维随机变量及其分布
- 离散数学蕴含式的问题
- uniapp App权限配置
- 司创电梯发卡软件_防复制电梯IC卡软件系统安装操作步骤
- maplesoft maple 2020
- [个人笔记]HCIP-Routing Switching-IERS/H12-221
- 在线电子书阅读微信小程序 毕业设计(3)图书列表
- S曲线C语言实现,利用robomodule+STM32F429+直流伺服电机进行简单验证
- springboot多数据源如何配置驼峰映射或配置文件不起作用的问题
- 100以内的数分解问题