基于Spark的FPGrowth算法的运用

最新推荐文章于 2021-08-06 10:08:30 发布
最新推荐文章于 2021-08-06 10:08:30 发布
阅读量758 收藏 2
点赞数
分类专栏： Spark2-mlib
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kwame211/article/details/80731503
版权

一、FPGrowth算法理解

        Spark.mllib 提供并行FP-growth算法，这个算法属于关联规则算法【关联规则：两不相交的非空集合A、B，如果A=>B，就说A=>B是一条关联规则，常提及的{啤酒}-->{尿布}就是一条关联规则】，经常用于挖掘频度物品集。关于算法的介绍网上很多，这里不再赘述。主要搞清楚几个概念：

1)支持度support(A => B) = P(AnB) = |A n B| / |N|，表示数据集D中，事件A和事件B共同出现的概率；

2)置信度confidence(A => B) = P(B|A) = |A n B| / |A|，表示数据集D中，出现事件A的事件中出现事件B的概率；

3）提升度lift(A => B) = P(B|A):P(B) = |A n B| / |A| : |B| / |N|，表示数据集D中，出现A的条件下出现事件B的概率和没有条件A出现B的概率；

由上可以看出，支持度表示这条规则的可能性大小，而置信度表示由事件A得到事件B的可信性大小。

举个列子：10000个消费者购买了商品，尿布1000个，啤酒2000个，同时购买了尿布和啤酒800个。 

1)支持度：在所有项集中出现的可能性，项集同时含有，x与y的概率。尿布和啤酒的支持度为：800/10000=8% 

2)置信度：在X发生的条件下，Y发生的概率。尿布-》啤酒的置信度为:800/1000=80%，啤酒-》尿布的置信度为：800/2000=40% 

3)提升度：在含有x条件下同时含有Y的可能性（x->y的置信度）比没有x这个条件下含有Y的可能性之比：confidence(尿布=> 啤酒)/概率(啤酒)) = 80%/(2000/10000) 。如果提升度=1，那就是没啥关系这两个

通过支持度和置信度可以得出强关联关系，通过提升的，可判别有效的强关联关系。

直接拿例子来说明问题。首先数据集如下：

[plain]  view plain  copy
  1. r z h k p  
  2. z y x w v u t s  
  3. s x o n r  
  4. x z y m t s q e  
  5. z  
  6. x z y r q t p  
二、代码实现。在IDEA中建立Maven工程，然后本地模式调试代码如下：
[java]  view plain  copy
  1. import org.apache.spark.SparkConf;  
  2. import org.apache.spark.api.java.JavaRDD;  
  3. import org.apache.spark.api.java.JavaSparkContext;  
  4. import org.apache.spark.api.java.function.Function;  
  5. import org.apache.spark.mllib.fpm.AssociationRules;  
  6. import org.apache.spark.mllib.fpm.FPGrowth;  
  7. import org.apache.spark.mllib.fpm.FPGrowthModel;  
  8.   
  9. import java.util.Arrays;  
  10. import java.util.List;  
  11.   
  12. public class FPDemo {  
  13.     public static void main(String[] args){  
  14.         String data_path;       //数据集路径  
  15.         double minSupport = 0.2;//最小支持度  
  16.         int numPartition = 10;  //数据分区  
  17.         double minConfidence = 0.8;//最小置信度  
  18.         if(args.length < 1){  
  19.             System.out.println("<input data_path>");  
  20.             System.exit(-1);  
  21.         }  
  22.         data_path = args[0];  
  23.         if(args.length >= 2)  
  24.             minSupport = Double.parseDouble(args[1]);  
  25.         if(args.length >= 3)  
  26.             numPartition = Integer.parseInt(args[2]);  
  27.         if(args.length >= 4)  
  28.             minConfidence = Double.parseDouble(args[3]);  
  29.   
  30.         SparkConf conf = new SparkConf().setAppName("FPDemo").setMaster("local");  
  31.         JavaSparkContext sc = new JavaSparkContext(conf);  
  32.   
  33.         //加载数据，并将数据通过空格分割  
  34.         JavaRDD<List<String>> transactions = sc.textFile(data_path)  
  35.                 .map(new Function<String, List<String>>() {  
  36.                     public List<String> call(String s) throws Exception {  
  37.                         String[] parts = s.split(" ");  
  38.                         return Arrays.asList(parts);  
  39.                     }  
  40.                 });  
  41.   
  42.         //创建FPGrowth的算法实例，同时设置好训练时的最小支持度和数据分区  
  43.         FPGrowth fpGrowth = new FPGrowth().setMinSupport(minSupport).setNumPartitions(numPartition);  
  44.         FPGrowthModel<String> model = fpGrowth.run(transactions);//执行算法  
  45.   
  46.         //查看所有频繁諅，并列出它出现的次数  
  47.         for(FPGrowth.FreqItemset<String> itemset : model.freqItemsets().toJavaRDD().collect())  
  48.             System.out.println("[" + itemset.javaItems() + "]," + itemset.freq());  
  49.   
  50.         //通过置信度筛选出强规则  
  51.         //antecedent表示前项  
  52.         //consequent表示后项  
  53.         //confidence表示规则的置信度  
  54.         for(AssociationRules.Rule<String> rule : model.generateAssociationRules(minConfidence).toJavaRDD().collect())  
  55.             System.out.println(rule.javaAntecedent() + "=>" + rule.javaConsequent() + ", " + rule.confidence());  
  56.     }  
  57. }  
       直接在Maven工程中运用上面的代码会有问题，因此这里需要添加依赖项解决项目中的问题，依赖项的添加如下：
[plain]  view plain  copy
  1. <dependencies>  
  2.         <dependency>  
  3.             <groupId>org.apache.spark</groupId>  
  4.             <artifactId>spark-core_2.10</artifactId>  
  5.             <version>2.1.0</version>  
  6.         </dependency>  
  7.         <dependency>  
  8.             <groupId>org.apache.spark</groupId>  
  9.             <artifactId>spark-mllib_2.10</artifactId>  
  10.             <version>2.1.0</version>  
  11.         </dependency>  
  12. </dependencies>  
        本地模式运行的结果如下：
[plain]  view plain  copy
  1. [t, s, y]=>[x], 1.0  
  2. [t, s, y]=>[z], 1.0  
  3. [y, x, z]=>[t], 1.0  
  4. [y]=>[x], 1.0  
  5. [y]=>[z], 1.0  
  6. [y]=>[t], 1.0  
  7. [p]=>[r], 1.0  
  8. [p]=>[z], 1.0  
  9. [q, t, z]=>[y], 1.0  
  10. [q, t, z]=>[x], 1.0  
  11. [q, y]=>[x], 1.0  
  12. [q, y]=>[z], 1.0  
  13. [q, y]=>[t], 1.0  
  14. [t, s, x]=>[y], 1.0  
  15. [t, s, x]=>[z], 1.0  
  16. [q, t, y, z]=>[x], 1.0  
  17. [q, t, x, z]=>[y], 1.0  
  18. [q, x]=>[y], 1.0  
  19. [q, x]=>[t], 1.0  
  20. [q, x]=>[z], 1.0  
  21. [t, x, z]=>[y], 1.0  
  22. [x, z]=>[y], 1.0  
  23. [x, z]=>[t], 1.0  
  24. [p, z]=>[r], 1.0  
  25. [t]=>[y], 1.0  
  26. [t]=>[x], 1.0  
  27. [t]=>[z], 1.0  
  28. [y, z]=>[x], 1.0  
  29. [y, z]=>[t], 1.0  
  30. [p, r]=>[z], 1.0  
  31. [t, s]=>[y], 1.0  
  32. [t, s]=>[x], 1.0  
  33. [t, s]=>[z], 1.0  
  34. [q, z]=>[y], 1.0  
  35. [q, z]=>[t], 1.0  
  36. [q, z]=>[x], 1.0  
  37. [q, y, z]=>[x], 1.0  
  38. [q, y, z]=>[t], 1.0  
  39. [y, x]=>[z], 1.0  
  40. [y, x]=>[t], 1.0  
  41. [q, x, z]=>[y], 1.0  
  42. [q, x, z]=>[t], 1.0  
  43. [t, y, z]=>[x], 1.0  
  44. [q, y, x]=>[z], 1.0  
  45. [q, y, x]=>[t], 1.0  
  46. [q, t, y, x]=>[z], 1.0  
  47. [t, s, x, z]=>[y], 1.0  
  48. [s, y, x]=>[z], 1.0  
  49. [s, y, x]=>[t], 1.0  
  50. [s, x, z]=>[y], 1.0  
  51. [s, x, z]=>[t], 1.0  
  52. [q, y, x, z]=>[t], 1.0  
  53. [s, y]=>[x], 1.0  
  54. [s, y]=>[z], 1.0  
  55. [s, y]=>[t], 1.0  
  56. [q, t, y]=>[x], 1.0  
  57. [q, t, y]=>[z], 1.0  
  58. [t, y]=>[x], 1.0  
  59. [t, y]=>[z], 1.0  
  60. [t, z]=>[y], 1.0  
  61. [t, z]=>[x], 1.0  
  62. [t, s, y, x]=>[z], 1.0  
  63. [t, y, x]=>[z], 1.0  
  64. [q, t]=>[y], 1.0  
  65. [q, t]=>[x], 1.0  
  66. [q, t]=>[z], 1.0  
  67. [q]=>[y], 1.0  
  68. [q]=>[t], 1.0  
  69. [q]=>[x], 1.0  
  70. [q]=>[z], 1.0  
  71. [t, s, z]=>[y], 1.0  
  72. [t, s, z]=>[x], 1.0  
  73. [t, x]=>[y], 1.0  
  74. [t, x]=>[z], 1.0  
  75. [s, z]=>[y], 1.0  
  76. [s, z]=>[x], 1.0  
  77. [s, z]=>[t], 1.0  
  78. [s, y, x, z]=>[t], 1.0  
  79. [s]=>[x], 1.0  
  80. [t, s, y, z]=>[x], 1.0  
  81. [s, y, z]=>[x], 1.0  
  82. [s, y, z]=>[t], 1.0  
  83. [q, t, x]=>[y], 1.0  
  84. [q, t, x]=>[z], 1.0  
  85. [r, z]=>[p], 1.0  

三、Spark集群部署。代码修改正如：

[java]  view plain  copy
  1. import org.apache.spark.SparkConf;  
  2. import org.apache.spark.api.java.JavaRDD;  
  3. import org.apache.spark.api.java.JavaSparkContext;  
  4. import org.apache.spark.api.java.function.Function;  
  5. import org.apache.spark.mllib.fpm.AssociationRules;  
  6. import org.apache.spark.mllib.fpm.FPGrowth;  
  7. import org.apache.spark.mllib.fpm.FPGrowthModel;  
  8.   
  9. import java.util.Arrays;  
  10. import java.util.List;  
  11.   
  12. public class FPDemo {  
  13.     public static void main(String[] args){  
  14.         String data_path;       //数据集路径  
  15.         double minSupport = 0.2;//最小支持度  
  16.         int numPartition = 10;  //数据分区  
  17.         double minConfidence = 0.8;//最小置信度  
  18.         if(args.length < 1){  
  19.             System.out.println("<input data_path>");  
  20.             System.exit(-1);  
  21.         }  
  22.         data_path = args[0];  
  23.         if(args.length >= 2)  
  24.             minSupport = Double.parseDouble(args[1]);  
  25.         if(args.length >= 3)  
  26.             numPartition = Integer.parseInt(args[2]);  
  27.         if(args.length >= 4)  
  28.             minConfidence = Double.parseDouble(args[3]);  
  29.   
  30.         SparkConf conf = new SparkConf().setAppName("FPDemo");修改的地方  
  31.         JavaSparkContext sc = new JavaSparkContext(conf);  
  32.   
  33.         //加载数据，并将数据通过空格分割  
  34.         JavaRDD<List<String>> transactions = sc.textFile(data_path)  
  35.                 .map(new Function<String, List<String>>() {  
  36.                     public List<String> call(String s) throws Exception {  
  37.                         String[] parts = s.split(" ");  
  38.                         return Arrays.asList(parts);  
  39.                     }  
  40.                 });  
  41.   
  42.         //创建FPGrowth的算法实例，同时设置好训练时的最小支持度和数据分区  
  43.         FPGrowth fpGrowth = new FPGrowth().setMinSupport(minSupport).setNumPartitions(numPartition);  
  44.         FPGrowthModel<String> model = fpGrowth.run(transactions);//执行算法  
  45.   
  46.         //查看所有频繁諅，并列出它出现的次数  
  47.         for(FPGrowth.FreqItemset<String> itemset : model.freqItemsets().toJavaRDD().collect())  
  48.             System.out.println("[" + itemset.javaItems() + "]," + itemset.freq());  
  49.   
  50.         //通过置信度筛选出强规则  
  51.         //antecedent表示前项  
  52.         //consequent表示后项  
  53.         //confidence表示规则的置信度  
  54.         for(AssociationRules.Rule<String> rule : model.generateAssociationRules(minConfidence).toJavaRDD().collect())  
  55.             System.out.println(rule.javaAntecedent() + "=>" + rule.javaConsequent() + ", " + rule.confidence());  
  56.     }  
  57. }  
       然后在IDEA中打包成JAR包



       然后在工具栏


生成Jar包，然后上传到集群中执行命令


        得到结果

DemonHunter211
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FP-Growth的spark实现算法
01-08
聚类分析常用算法FP-Growth的spark实现算法,
基于Spark的FPGrowth（关联规则算法）
热门推荐
猫爷大数据学习笔记
10-24 1万+
在推荐中，关联规则推荐使用的比较频繁，毕竟是通过概率来预测的，易于理解且准确度比较高，不过有一个缺点为，想要覆盖推荐物品的数量，就要降低支持度与置信度。过高的支持度与置信度会导致物品覆盖不过，这里需要其他的推荐方法合作，建议使用基于Spark的模型推荐算法（矩阵分解+ALS）.一FPGrowth算法描述：FPGrowth算法概念：支持度，置信度，提升度(Spark好像没有计算这个的函数，需要自己计算
四、关联规则挖掘之FP-Growth
Wmnyang的博客
05-27 850
同步更新公众号：海涛技术漫谈 频繁项挖掘广泛的应用于寻找关联的事物。最经典的就是，电商企业通过分析用户的订单，挖掘出经常被共同购买的商品，用于推荐。 本文首先介绍频繁项挖掘技术的演进，从暴力求解到Aprioir算法。然后，通过一个案例详细的讲解FP-Growth的原理。接下来介绍并行FP-Growt...
Spark 机器学习 FPGrowth
ynyeel的博客
08-06 469
机器学习—FPGrowth 用于发现频繁项集 应用场景：我们常说的： 啤酒+尿布 假设我们购买的如下： 解释：每一行都是一条购买记录，transaction表示每次购买的是哪几样商品，sort这列是按所有商品购买次数的多少，从大到小排列。 从上表可以看出 B(6次), E(5次), A(4次), C(4次), D(4次) 然后我们就按数量从大到小排，每次Sort的顺序都是BEACD 假设最低支持度为3： 根据上述的分析，我们从高到低画出的图如下： 根据上图，FPGrowth挖掘过程如下（从低
Spark数据挖掘-FPGrowth算法
chengtuo5899的博客
11-03 287
Spark数据挖掘-FPGrowth算法 主要内容 什么是关联规则挖掘？ 关联规则有哪些术语？ 什么是FP-Growth算法？ 1.1 FPGrowth算法 1.1.1 基本概念 关联规则挖掘的一个典型例子是购物篮分析。关联规则研究有助于发现交易数据库中不同商品（项）之间的联系，找出顾客购...
spark FPGrowth笔记
u013303361的专栏
06-04 377
问题1：树深度无限制问题 这频繁项 子集深度不加限制，感觉不合理，，，好比词袋模型词袋任意长了；若不在前面手动限制 频繁项 最大长度，我的笔记本直接运行不出来，我的笔记本必须限制到30以内size(ids)<30。 问题2：参数含义setMinSupport(0.001) // 频繁项（热门商品）在总体的最小（出现）比例 追溯从fit到genericFit就发现minCount= math.ceil(minSupport * count)，再到genFreqItems发现解释为“m..
数据挖掘（2）：关联规则FpGrowth算法
onlyForCloud的专栏
09-12 1090
http://blog.jobbole.com/90125/ 原文出处： fengfenggirl（@也爱数据挖掘）   欢迎分享原创到伯乐头条 上一篇介绍了关联规则挖掘的一些基本概念和经典的Apriori算法，Aprori算法利用频繁集的两个特性，过滤了很多无关的集合，效率提高不少，但是我们发现Apriori算法是一个候选消除算法，每一次消除都需要扫描一次所有数据记录，造成整
FPGrowth 关联规则
huangkang1995的博客
03-25 1544
Spark MLlib关联算法概述 Spark MLlib关联算法基于Python的接口在pyspark.mllib.fpm包中。FP Tree算法对应的类是pyspark.mllib.fpm.FPGrowth(以下简称FPGrowth类)，从Spark1.4开始才有。而PrefixSpan算法对应的类是pyspark.mllib.fpm.PrefixSpan(以下简称PrefixSpan类)，...
【机器学习系列2】FPGrowth算法与spark实现
安全曼巴2020
09-07 3476
原理 基础 支持度 支持度是指在所有项集中{X, Y}出现的可能性，即项集中同时含有X和Y的概率： 该指标作为建立强关联规则的第一个门槛，衡量了所考察关联规则在“量”上的多少。 置信度 置信度表示在先决条件X发生的条件下，关联结果Y发生的概率： 这是生成强关联规则的第二个门槛，衡量了所考察的关联规则在“质”上的可靠性。 提升度 提升度表示在含有X的条件下同时含有Y的可
Spark下的FP-Growth和Apriori（频繁项集挖掘并行化算法）
mangoer_ys
02-01 1万+
频繁项集挖掘是一个关联式规则挖掘问题。关联挖掘是数据挖掘中研究最早也是最活跃的领域，其中频繁模式的挖掘是关联挖掘的核心和基础，是产生关联规则挖掘的基础。其中FP-Growth和Apriori算法是最为经典的频繁项集挖掘算法。本文在spark下利用scala编写，充分利用了spark的内存计算方式和scala简洁的语法模式和先天性的并行化特性，充分发挥了FP-Growth。
FP_Growth算法案例讲解和演示
08-17
资源包含了FP-tree算法的演示文本、算法源码的讲解、可执行程序的演示以及可编译程序代码，通过这些资源，你可以掌握fp_tree 算法的原理和树的创建过程。
Spark MLlib FPGrowth算法
Spark MLlib 机器学习
05-09 1万+
1.1 FPGrowth算法 1.1.1 基本概念 关联规则挖掘的一个典型例子是购物篮分析。关联规则研究有助于发现交易数据库中不同商品（项）之间的联系，找出顾客购买行为模式，如购买了某一商品对购买其他商品的影响，分析结果可以应用于商品货架布局、货存安排以及根据购买模式对用户进行分类。 关联规则的相关术语如下： （1）项与项集 这是一个集合的概念，在一篮子商品中的一件消费品即为一项（Ite
Spark的模式挖掘—FPGrowth算法
oxuzhenyi的博客
06-03 4373
Spark的模式挖掘—FPGrowth算法 一、实验介绍 1.1 内容介绍 模式挖掘也叫关联规则，其实就是从大量的数据中挖掘出比较有用的数据，挖掘频繁项。比如说超市有大量的购物数据，从而可以根据用户的购物数据找到哪些商品关联性比较大。也可以进行用户推荐。下面我们说一个真实的案例。 我想可能有些同学一定听说过尿布和啤酒的故事吧。就是在一家超市里尿布和啤酒摆在一起出售。但是这个
Spark MLlib中FPGrowth和FPTree详解之二
LULIN60的专栏
08-20 3935
这一章节，主要介绍FPGrowth源码，以及运行过程演示 2.3 FPGrowth源码详解 run方法是FPGrowth的入口函数，其代码注释如下： /**   * Computes an FP-Growth model that contains frequent itemsets.   * @param data input data set, each element con
fpgrowth算法实战 mlib_【spark】41.Spark Mlib：FPGrowth算法
weixin_35160923的博客
01-14 932
简介FP-Growth算法是韩嘉炜等人在2000年提出的关联分析算法，它采取如下分治策略：将提供频繁项集的数据库压缩到一棵频繁模式树(FP-tree)，但仍保留项集关联信息。在算法中使用了一种称为频繁模式树(Frequent Pattern Tree)的数据结构。FP-tree是一种特殊的前缀树，由频繁项头表和项前缀树构成。FP-Growth算法基于以上的结构加快整个挖掘过程。众所周知，Aprio...
SparkML模型选择（超参数调整）与调优
大数据星球-浪尖
12-10 3879
Spark ML模型选择与调优本文主要讲解如何使用Spark MLlib的工具去调优ML算法和Pipelines。内置的交叉验证和其他工具允许用户优化算法和管道中的超参数。模型选择（又称为超参数调整）ML中的一个重要任务是模型选择，或者使用数据来找出给定任务的最佳模型或参数。这也被称为调优。可以针对单个独立的Estimator进行调优，例如LogisticRegression，也可以针对整个Pip
数据挖掘算法之FP-Growth算法介绍及Spark代码实现
superMario
03-30 1085
FP-Growth算法概述阶段1：FP树构建步骤1：清洁和分类步骤2：构造FP树，带有已清理项目集的头表阶段2：开采主要树和条件FP树步骤1：将主要FP树划分为条件FP树步骤2：递归地挖掘每个条件树使用SPARK实现算法 FP树是整个FP Growth算法的核心概念。简而言之，FP树是项集数据库的压缩表示形式。树结构不仅在数据库中保留了项目集，而且还跟踪项目集之间的关联 通过获取每个项目集并将其一次映射到树中的路径来构造树。这种结构背后的整个想法是发生频率更高的项集将有更好的机会共享项集 然后，我们递归地挖
【spark】41.Spark Mlib：FPGrowth算法
weixin_33790053的博客
02-21 246
2019独角兽企业重金招聘Python工程师标准>>> ...
如何基于Spark ML实现FP-growth算法
最新发布
05-29
要基于Spark ML实现FP-growth算法，需要按照以下步骤： 1. 数据准备：将数据转换为适合FP-growth算法的格式，即将数据集转换为交易列表，其中每个交易是一个项集。 2. 构建模型：使用Spark ML的FP-growth实现构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值