使用Apriori算法进行关联分析

最新推荐文章于 2022-08-16 17:39:18 发布
最新推荐文章于 2022-08-16 17:39:18 发布
阅读量299 收藏 1
点赞数
分类专栏： 机器学习 文章标签： Apriori算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuyuhuo6777/article/details/86007185
版权

关联分析是一种在大规模数据集中寻找有趣关系的任务。这些关系可以有两种形式

频繁项集：经常出现在一块的物品的集合

关联规则：暗示两种物品之间可能存在很强的关系

Apriori 原理

 

 

关联分析

 

 

 

：

Xavier学长
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习实战—使用Apriori算法进行关联分析
zoinsung_lee的博客
05-04 7886
从大规模数据集中寻找物品间的隐含关系被称作关联分析或者关联规则学习。 一、关联分析 频繁项集：经常出现在一块的集合。 关联规则：按时两种物品之间可能存在很强的关系。 支持度：一个项集的支持度被定义为数据集中包含该项集的记录所占的比例。 可信度或置信度：是针对诸如{尿布}—>{葡萄酒}的关联规则来定义的，这条规则的可信度被定义为：支持度（{尿布，葡萄酒}）/支持度（{尿布}） 支持...
使用 Apriori 算法进行关联分析（机器学习）
热门推荐
sikh_0529的博客
09-13 1万+
为了降低计算次数和时间，研究人员发现了一种所谓的 Apriori 原理，即某个项集是频繁的，那么它的所有子集也是频繁的。例如，如果 {0, 1} 是频繁的，那么 {0}, {1} 也是频繁的。的之后，就不需要再计算 {0,2,3} {1,2,3} {0,1,2,3} 的支持度，因为我们知道这些集合不会满足我们的要求。，那么利用上面的知识，我们就可以知道 {0,2,3} {1,2,3} {0,1,2,3} 都是。可以利用关联规则的上述性质属性来减少需要测试的规则数目，跟先前 Apriori 算法的套路一样。
使用Apriori算法进行关联规则挖掘的实验报告与代码实现
04-06
本实验报告主要聚焦于使用Apriori算法进行关联规则挖掘，这是由Rakesh Agrawal和Ramakrishnan Srikant在1994年提出的经典算法。此算法主要应用于零售数据分析，例如发现顾客购买商品之间的关联性。 Apriori算法的...
python使用Apriori算法进行关联性解析
12-23
从大规模数据集中寻找物品间的隐含关系被称作关联分析或关联规则学习。过程分为两步：1.提取频繁项集。2.从频繁项集中抽取出关联规则。 频繁项集是指经常出现在一块的物品的集合。 关联规则是暗示两种物品之间...
Apriori算法对购物篮进行关联分析-Apriori算法进行购物篮关联分析.rar
08-12
Apriori算法对购物篮进行关联分析-Apriori算法进行购物篮关联分析.rar 大家好，出来乍到，看到好多高手分享自己的程序，我也想分享一下，做出自己的贡献。 虽然学MATLAB已经一年有余，但是一直忙着数学建模，对...
使用apriori算法进行关联分析
Just for fun的专栏
10-07 1069
关联分析：从大规模数据集中寻找物品之间的隐含关系。目标包括两项：发现频繁项集和发现关联规则 　　主要问题在于，寻找物品的不同组合是一项十分耗时的任务，所需的计算代价很高，蛮力搜索方法并不能解决这个问题。 一、关联分析 　　｛尿布与啤酒｝ 　　Apriori算法 　　　　优点：易编码实现 　　　　缺点：在大数据上可能较慢 　　　　适用数据类型：数值型或者标称型数据 　　频繁项集(fr
机器学习实战：使用 Apriori 算法进行关联分析
RexT1的博客
12-28 933
机器学习实战：使用 Apriori 算法进行关联分析 从大规模数据集中寻找物品间的隐 含关系被称作关联分析（association analysis）或者关联规则学习（association rule learning）。这 里的主要问题在于，寻找物品的不同组合是一项十分耗时的任务，所需的计算代价很高，蛮力搜 索方法并不能解决这个问题，所以需要用更智能的方法在合理的时间范围内找到频繁项集。本章 将介绍如何使用Apriori算法来解决上述问题。
【机器学习实战-11章】使用Apriori算法进行关联分析
lynn_flame的博客
06-04 992
使用Apriori算法进行关联分析 从大规模数据集中寻找物品间的隐含关系被称作关联分析(association analysis) 11.1 关联分析 优缺点 优点：易编码实现 缺点：在大数据集上可能较慢 概念 关联分析是一种在大规模数据集中寻找有趣关系的任务。这些关系可以有两种形式：频繁项集或者关联规则。 频繁项集(frequent item sets):经常出现在一块的物品的集合 关联规则：暗示两种物品之间可能存在很强的关系 支持度(support):定义为数据集中包含该项集的记录所占的比例。
《机器学习实战》之十一——使用Apriori算法进行关联分析
潘多拉星系的专栏
04-12 3945
Apriori算法目录一、前言二、关联分析三、Apriori原理四、利用Apriori算法来发现频繁集1、Apriori算法及实例描述2、生成候选项集2、组织完整的Apriori算法五、从频繁项集中挖掘关联规则六、示例1：发现国会投票中的模式七、示例2：发现毒蘑菇的相似特征八、总结参考文献 一、前言   Apriori算法是一种用于关联规则挖掘（Association rule mining）的代...
机器学习实战（十一）——使用Apriori算法进行关联分析
FavoriteStar的博客
08-16 1811
机器学习实战（十一）——使用Apriori算法进行关联分析
机器学习实战---读书笔记： 第11章 使用Apriori算法进行关联分析
qingyuanluofeng的专栏
02-11 442
#!/usr/bin/env python # encoding: utf-8 ''' <<机器学习实战>> 读书笔记 第11章 使用Apriori算法进行关联分析 关键: 1 关联分析 含义:从大规模数据集中寻找物品之间的隐含关系 主要问题: 暴力搜索物品的不同组合很困难 2 Apriori算法 优点: 容易编码实现 缺点: 在大数据集上可能较慢 适用数据类型: ...
Python3.6-Apriori算法进行关联分析
PeaYingluck的博客
09-20 2333
python3.6机器学习实战第11章代码问题总结 程序清单11-1 from numpy import * def loadDataSet(): return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]] def createC1(dataSet): C1=[] for transaction in dataSet: f
Apriori算法进行关联分析实战
CurryCoder的个人博客
05-19 2292
使用Apriori算法进行关联分析(层次聚类) 一、基础知识 1.关联分析定义及存在的问题 定义：从大规模的数据集中寻找物品间的隐含关系，被称为关联分析或关联规则学习。 关联分析存在的主要问题：主要问题在于寻找不同物品的组合是一项很耗时的任务，所需要的计算代价很高，暴力方法无法解决这个问题，所以使用更加合理的方法在合理的时间范围内找到频繁项集。 2.Apriori算法的优缺点及适用场合 ...
应用Aprion算法实现web与数据库关联规则做挖掘
AlphaH的技术之旅
02-08 1395
前几天看某人（百度兜哥）的一篇文章，在评论区看到利用Aprion算法做web与数据库的关联分析，这也是我之前在蓝盾做数据库审计时候想解决的一个三层关联的问题，在这里记录记录一下，以备以后如果再做类似产品的时候，可以用这个思路解决。...
Aprori算法[关联规则算法]
weixin_34023982的博客
11-29 133
1 <meta http-equiv="Content-Type" content="text/html; charset=GBK" /> 2 <?php 3 /* 4 *Apriori算法（关联规则算法的实现） 5 */ 6 7 /* 8 *项目集X支持G个数小于等于1去除 9 */ 10 //---------...
使用apriori对英文文本进行频繁项挖掘
kandysoso的博客
12-14 591
使用apriori对英文文本进行频繁项挖掘知识储备频繁项集，关联性分析apriori算法运行环境run结果及分析欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 知识储备 频繁项集，关联性分析
java使用Apriori算法进行关联分析
最新发布
05-17
Apriori算法是一种基于频繁项集的关联规则挖掘算法，它可以用来发现事物之间的相关性，并且在市场营销、销售预测、商品推荐等领域都有广泛的应用。 Java中实现Apriori算法主要分为以下步骤： 1. 数据预处理：将原始数据转化为事务集合形式，每个事务包含多个项，项之间用逗号或其他符号分隔。 2. 建立候选项集：根据用户设定的最小支持度阈值，生成大小为1的候选项集。 3. 频繁项集生成：根据候选项集和事务数据集，计算每个项集的支持度，并根据最小支持度阈值筛选出频繁项集。 4. 关联规则挖掘：根据频繁项集，生成关联规则，并计算每个规则的置信度和支持度。 以下是一个简单的Java代码实现： ``` public class Apriori { // 计算候选项集 public static List<Set<String>> candidateSet(List<Set<String>> frequentItemSets) { List<Set<String>> candidateSets = new ArrayList<>(); for (int i = 0; i < frequentItemSets.size(); i++) { for (int j = i + 1; j < frequentItemSets.size(); j++) { Set<String> set1 = frequentItemSets.get(i); Set<String> set2 = frequentItemSets.get(j); // 求并集 Set<String> candidateSet = new HashSet<>(set1); candidateSet.addAll(set2); if (candidateSet.size() == set1.size() + 1) { candidateSets.add(candidateSet); } } } return candidateSets; } // 计算支持度 public static int supportCount(List<Set<String>> transactions, Set<String> itemSet) { int count = 0; for (Set<String> transaction : transactions) { if (transaction.containsAll(itemSet)) { count++; } } return count; } // 计算频繁项集 public static List<Set<String>> frequentItemSet(List<Set<String>> transactions, double minSupport) { List<Set<String>> frequentItemSets = new ArrayList<>(); Map<Set<String>, Integer> itemSetCount = new HashMap<>(); // 统计每个项集的支持度计数 for (Set<String> transaction : transactions) { for (String item : transaction) { Set<String> itemSet = new HashSet<>(); itemSet.add(item); if (itemSetCount.containsKey(itemSet)) { itemSetCount.put(itemSet, itemSetCount.get(itemSet) + 1); } else { itemSetCount.put(itemSet, 1); } } } // 获得频繁项集 for (Set<String> itemSet : itemSetCount.keySet()) { double support = (double) itemSetCount.get(itemSet) / transactions.size(); if (support >= minSupport) { frequentItemSets.add(itemSet); } } // 迭代计算频繁项集 List<Set<String>> lastItemSets = frequentItemSets; while (!lastItemSets.isEmpty()) { List<Set<String>> candidateSets = candidateSet(lastItemSets); itemSetCount.clear(); for (Set<String> transaction : transactions) { for (Set<String> candidateSet : candidateSets) { if (transaction.containsAll(candidateSet)) { if (itemSetCount.containsKey(candidateSet)) { itemSetCount.put(candidateSet, itemSetCount.get(candidateSet) + 1); } else { itemSetCount.put(candidateSet, 1); } } } } lastItemSets = new ArrayList<>(); for (Set<String> itemSet : itemSetCount.keySet()) { double support = (double) itemSetCount.get(itemSet) / transactions.size(); if (support >= minSupport) { frequentItemSets.add(itemSet); lastItemSets.add(itemSet); } } } return frequentItemSets; } // 计算关联规则 public static List<Rule> associationRules(List<Set<String>> transactions, double minSupport, double minConfidence) { List<Rule> rules = new ArrayList<>(); List<Set<String>> frequentItemSets = frequentItemSet(transactions, minSupport); for (Set<String> frequentItemSet : frequentItemSets) { if (frequentItemSet.size() > 1) { List<Set<String>> subSets = getSubSets(frequentItemSet); for (Set<String> subSet : subSets) { Set<String> complementSet = new HashSet<>(frequentItemSet); complementSet.removeAll(subSet); double confidence = (double) supportCount(transactions, frequentItemSet) / supportCount(transactions, subSet); if (confidence >= minConfidence) { rules.add(new Rule(subSet, complementSet, confidence)); } } } } return rules; } // 获取所有子集 public static List<Set<String>> getSubSets(Set<String> itemSet) { List<Set<String>> subSets = new ArrayList<>(); if (itemSet.isEmpty()) { subSets.add(itemSet); } else { List<Set<String>> subSetsWithoutFirst = getSubSets(itemSet.stream().skip(1).collect(Collectors.toSet())); subSets.addAll(subSetsWithoutFirst); subSetsWithoutFirst.forEach(subSet -> { Set<String> subSetWithFirst = new HashSet<>(subSet); subSetWithFirst.add(itemSet.iterator().next()); subSets.add(subSetWithFirst); }); } return subSets; } // 关联规则类 public static class Rule { private Set<String> antecedent; private Set<String> consequent; private double confidence; public Rule(Set<String> antecedent, Set<String> consequent, double confidence) { this.antecedent = antecedent; this.consequent = consequent; this.confidence = confidence; } public Set<String> getAntecedent() { return antecedent; } public Set<String> getConsequent() { return consequent; } public double getConfidence() { return confidence; } @Override public String toString() { return antecedent + " => " + consequent + " (confidence: " + confidence + ")"; } } public static void main(String[] args) { List<Set<String>> transactions = new ArrayList<>(); transactions.add(new HashSet<>(Arrays.asList("A", "B", "C"))); transactions.add(new HashSet<>(Arrays.asList("A", "C", "D", "E"))); transactions.add(new HashSet<>(Arrays.asList("A", "C", "E", "F"))); transactions.add(new HashSet<>(Arrays.asList("B", "C", "E"))); transactions.add(new HashSet<>(Arrays.asList("B", "D", "E", "F"))); double minSupport = 0.4; double minConfidence = 0.7; List<Rule> rules = associationRules(transactions, minSupport, minConfidence); rules.forEach(System.out::println); } } ``` 以上代码实现了Apriori算法中的候选项集计算、支持度计算、频繁项集计算和关联规则挖掘等步骤。你可以根据自己的需求进行调整和修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值