基于Spark的FPGrowth算法的运用

最新推荐文章于 2021-06-22 21:28:12 发布
最新推荐文章于 2021-06-22 21:28:12 发布
阅读量8k 收藏 9
点赞数 1
分类专栏： DM&DL&ML
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012050154/article/details/54588124
版权

一、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，那就是没啥关系这两个

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

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

r z h k p
z y x w v u t s
s x o n r
x z y m t s q e
z
x z y r q t p
二、代码实现。在IDEA中建立Maven工程，然后本地模式调试代码如下： 
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.mllib.fpm.AssociationRules;
import org.apache.spark.mllib.fpm.FPGrowth;
import org.apache.spark.mllib.fpm.FPGrowthModel;

import java.util.Arrays;
import java.util.List;

public class FPDemo {
    public static void main(String[] args){
        String data_path;       //数据集路径
        double minSupport = 0.2;//最小支持度
        int numPartition = 10;  //数据分区
        double minConfidence = 0.8;//最小置信度
        if(args.length < 1){
            System.out.println("<input data_path>");
            System.exit(-1);
        }
        data_path = args[0];
        if(args.length >= 2)
            minSupport = Double.parseDouble(args[1]);
        if(args.length >= 3)
            numPartition = Integer.parseInt(args[2]);
        if(args.length >= 4)
            minConfidence = Double.parseDouble(args[3]);

        SparkConf conf = new SparkConf().setAppName("FPDemo").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        //加载数据，并将数据通过空格分割
        JavaRDD<List<String>> transactions = sc.textFile(data_path)
                .map(new Function<String, List<String>>() {
                    public List<String> call(String s) throws Exception {
                        String[] parts = s.split(" ");
                        return Arrays.asList(parts);
                    }
                });

        //创建FPGrowth的算法实例，同时设置好训练时的最小支持度和数据分区
        FPGrowth fpGrowth = new FPGrowth().setMinSupport(minSupport).setNumPartitions(numPartition);
        FPGrowthModel<String> model = fpGrowth.run(transactions);//执行算法

        //查看所有频繁諅，并列出它出现的次数
        for(FPGrowth.FreqItemset<String> itemset : model.freqItemsets().toJavaRDD().collect())
            System.out.println("[" + itemset.javaItems() + "]," + itemset.freq());

        //通过置信度筛选出强规则
        //antecedent表示前项
        //consequent表示后项
        //confidence表示规则的置信度
        for(AssociationRules.Rule<String> rule : model.generateAssociationRules(minConfidence).toJavaRDD().collect())
            System.out.println(rule.javaAntecedent() + "=>" + rule.javaConsequent() + ", " + rule.confidence());
    }
}
       直接在Maven工程中运用上面的代码会有问题，因此这里需要添加依赖项解决项目中的问题，依赖项的添加如下： 
<dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.10</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-mllib_2.10</artifactId>
            <version>2.1.0</version>
        </dependency>
</dependencies>
        本地模式运行的结果如下： 
[t, s, y]=>[x], 1.0
[t, s, y]=>[z], 1.0
[y, x, z]=>[t], 1.0
[y]=>[x], 1.0
[y]=>[z], 1.0
[y]=>[t], 1.0
[p]=>[r], 1.0
[p]=>[z], 1.0
[q, t, z]=>[y], 1.0
[q, t, z]=>[x], 1.0
[q, y]=>[x], 1.0
[q, y]=>[z], 1.0
[q, y]=>[t], 1.0
[t, s, x]=>[y], 1.0
[t, s, x]=>[z], 1.0
[q, t, y, z]=>[x], 1.0
[q, t, x, z]=>[y], 1.0
[q, x]=>[y], 1.0
[q, x]=>[t], 1.0
[q, x]=>[z], 1.0
[t, x, z]=>[y], 1.0
[x, z]=>[y], 1.0
[x, z]=>[t], 1.0
[p, z]=>[r], 1.0
[t]=>[y], 1.0
[t]=>[x], 1.0
[t]=>[z], 1.0
[y, z]=>[x], 1.0
[y, z]=>[t], 1.0
[p, r]=>[z], 1.0
[t, s]=>[y], 1.0
[t, s]=>[x], 1.0
[t, s]=>[z], 1.0
[q, z]=>[y], 1.0
[q, z]=>[t], 1.0
[q, z]=>[x], 1.0
[q, y, z]=>[x], 1.0
[q, y, z]=>[t], 1.0
[y, x]=>[z], 1.0
[y, x]=>[t], 1.0
[q, x, z]=>[y], 1.0
[q, x, z]=>[t], 1.0
[t, y, z]=>[x], 1.0
[q, y, x]=>[z], 1.0
[q, y, x]=>[t], 1.0
[q, t, y, x]=>[z], 1.0
[t, s, x, z]=>[y], 1.0
[s, y, x]=>[z], 1.0
[s, y, x]=>[t], 1.0
[s, x, z]=>[y], 1.0
[s, x, z]=>[t], 1.0
[q, y, x, z]=>[t], 1.0
[s, y]=>[x], 1.0
[s, y]=>[z], 1.0
[s, y]=>[t], 1.0
[q, t, y]=>[x], 1.0
[q, t, y]=>[z], 1.0
[t, y]=>[x], 1.0
[t, y]=>[z], 1.0
[t, z]=>[y], 1.0
[t, z]=>[x], 1.0
[t, s, y, x]=>[z], 1.0
[t, y, x]=>[z], 1.0
[q, t]=>[y], 1.0
[q, t]=>[x], 1.0
[q, t]=>[z], 1.0
[q]=>[y], 1.0
[q]=>[t], 1.0
[q]=>[x], 1.0
[q]=>[z], 1.0
[t, s, z]=>[y], 1.0
[t, s, z]=>[x], 1.0
[t, x]=>[y], 1.0
[t, x]=>[z], 1.0
[s, z]=>[y], 1.0
[s, z]=>[x], 1.0
[s, z]=>[t], 1.0
[s, y, x, z]=>[t], 1.0
[s]=>[x], 1.0
[t, s, y, z]=>[x], 1.0
[s, y, z]=>[x], 1.0
[s, y, z]=>[t], 1.0
[q, t, x]=>[y], 1.0
[q, t, x]=>[z], 1.0
[r, z]=>[p], 1.0

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

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.mllib.fpm.AssociationRules;
import org.apache.spark.mllib.fpm.FPGrowth;
import org.apache.spark.mllib.fpm.FPGrowthModel;

import java.util.Arrays;
import java.util.List;

public class FPDemo {
    public static void main(String[] args){
        String data_path;       //数据集路径
        double minSupport = 0.2;//最小支持度
        int numPartition = 10;  //数据分区
        double minConfidence = 0.8;//最小置信度
        if(args.length < 1){
            System.out.println("<input data_path>");
            System.exit(-1);
        }
        data_path = args[0];
        if(args.length >= 2)
            minSupport = Double.parseDouble(args[1]);
        if(args.length >= 3)
            numPartition = Integer.parseInt(args[2]);
        if(args.length >= 4)
            minConfidence = Double.parseDouble(args[3]);

        SparkConf conf = new SparkConf().setAppName("FPDemo");修改的地方
        JavaSparkContext sc = new JavaSparkContext(conf);

        //加载数据，并将数据通过空格分割
        JavaRDD<List<String>> transactions = sc.textFile(data_path)
                .map(new Function<String, List<String>>() {
                    public List<String> call(String s) throws Exception {
                        String[] parts = s.split(" ");
                        return Arrays.asList(parts);
                    }
                });

        //创建FPGrowth的算法实例，同时设置好训练时的最小支持度和数据分区
        FPGrowth fpGrowth = new FPGrowth().setMinSupport(minSupport).setNumPartitions(numPartition);
        FPGrowthModel<String> model = fpGrowth.run(transactions);//执行算法

        //查看所有频繁諅，并列出它出现的次数
        for(FPGrowth.FreqItemset<String> itemset : model.freqItemsets().toJavaRDD().collect())
            System.out.println("[" + itemset.javaItems() + "]," + itemset.freq());

        //通过置信度筛选出强规则
        //antecedent表示前项
        //consequent表示后项
        //confidence表示规则的置信度
        for(AssociationRules.Rule<String> rule : model.generateAssociationRules(minConfidence).toJavaRDD().collect())
            System.out.println(rule.javaAntecedent() + "=>" + rule.javaConsequent() + ", " + rule.confidence());
    }
}
       然后在IDEA中打包成JAR包



       然后在工具栏


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


        得到结果


行者小朱
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
论文研究-基于Spark的FP_Growth算法的并行与优化.pdf
09-12
PFP_Growth算法是FP_Growth算法在Hadoop平台上基于MapReduce的并行化，该算法在分组过程中没有考虑负载均衡问题，导致各个节点完成任务时间不一致，甚至相差很大，从而降低了算法的执行效率。为了提高算法的执行效率，提出了一种基于Spark的RPFP算法，该算法对PFP_Growth算法在均衡分组和降低时间复杂度两方面进行优化，通过把负载大的项放在负载总和最小的组里面实现均衡分组，通过在链头表结构中加入一张哈希表达到快速访问元素地址的目的，从而降低时间复杂度。实验结果表明，RPFP通过优化PFP算法，有效提高了频繁项集的挖掘效率。
基于Spark的蚁群优化算法
02-25
<span><span xss=removed><span>组合优化问题求解的困难程度会随着问题规模的增大而呈指数型增长，即所谓的“组合爆炸”现象。而随着大数据时代的来临，组合优化问题规模越来越大，使得该问题愈加突出。因此，为应对大数据时代中组合优化问题的求解，基于云计算框架</span></span></span><span><span xss=removed>Spark</span></span><span><span xss=removed>，借助其基于内存、分布式的特定，提出一种并行蚁群优化算法。其思路是通过将蚂蚁构造为弹性分布式数据集，由此给出相应的一系列转换算子，实现了蚂蚁构造解过程的并行化。通过在旅行商问题求解的仿真实验结果说明了所提出的并行算法的可行性；并在同等实验环境下对比基于</span></span><span>
基于Spark+PageRank算法构建仿微博用户好友的分布式推荐系统.zip
10-23
基于Spark+PageRank算法构建仿微博用户好友的分布式推荐系统.zip 1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、电子信息等)正在做课程设计、期末大作业和毕设项目的学生、或者相关技术学习者作为学习资料参考使用。 3、该资源包括全部源码，需要具备一定基础才能看懂并调试代码。 基于Spark+PageRank算法构建仿微博用户好友的分布式推荐系统.zip 1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、电子信息等)正在做课程设计、期末大作业和毕设项目的学生、或者相关技术学习者作为学习资料参考使用。 3、该资源包括全部源码，需要具备一定基础才能看懂并调试代码。 基于Spark+PageRank算法构建仿微博用户好友的分布式推荐系统.zip 1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、电子信息等)正在做课程设计、期末大作业和毕设项目的学生、或者相关技术学习者作
基于Spark的并行社区发现算法
04-30
针对大规模图数据顶点聚类进行研究，提出了一种基于Spark的并行社区发现算法，其在基于极值优化的串行社区发现算法的基础上设计而成。此外还针对该串行算法在簇调整时因选择顶点数量过少而影响算法运行效率的问题，提出了一种多个顶点选择方法。该方法会计算一个阈值并发现所有适应度值小于该阈值的顶点，作为被选择的顶点；由于阈值是基于所有顶点的适应度值计算出来的，为了避免非常大的适应度值对阈值造成的影响该方法会限制被选择顶点的数量，若被选择的顶点过多，算法只保留其中的一部分。同时，还提出了一种顶点过滤方法，其可以有效减少图数据的数据量。实验表明，提出算法的运行时间明显短于比较的其他基于Spark的并行化社区发现算法，可以发现其运行速度相对较快。
基于Java的Spark协同过滤FPGrowth和皮尔森关联分析Pearson设计源码
最新发布
04-03
本设计源码提供了一个基于Java的Spark协同过滤FPGrowth和皮尔森关联分析Pearson的设计。项目包含122个文件，主要使用Java编程语言。文件类型包括106个Java源代码文件、8个TXT文件、2个Markdown文档、2个XML配置文件、2个YAML配置文件和1个Git忽略文件。该设计涵盖了Spark的协同过滤FPGrowth、皮尔森关联分析Pearson以及斯皮克曼关联分析spearman算法。适合用于学习和实践Java技术，以及开发基于Spark的协同过滤和关联分析相关的系统。
频繁模式挖掘-FP-Growth
sccdpxz2的博客
03-02 882
算法简介 FP-Growth是频繁模式挖掘的一种算法，由韩家炜等在2000年提出，算法通过建立一棵频繁项集树来实现频繁项集的搜索，同时能实现事务的压缩，相比Apriori能减少数据的扫描次数。 算法逻辑 1、扫描数据，统计项目（item）在数据集中出现的频数，例如苹果出现（被购买）了4次、牛奶出现（被购买）了5次等 2、再次扫描数据，构建频繁树（FP-Tree），并生成头表。将每条事物中的项目按照步骤1中的频数由高到底排列后，依次放到树中，并用头表记录每个项目在树中的位置 3、依据头表...
朴素贝叶斯分类sparkmllib测试
花羽的博客
05-15 1272
贝叶斯分类的基础——贝叶斯定理   每次提到贝叶斯定理，我心中的崇敬之情都油然而生，倒不是因为这个定理多高深，而是因为它特别有用。这个定理解决了现实生活里经常遇到的问题：已知某条件概率，如何得到两个事件交换后的概率，也就是在已知P(A|B)的情况下如何求得P(B|A)。这里先解释什么是条件概率： P(A|B) 表示事件B已经发生的前提下，事件A发生的概率，叫做事件B发生下事件A的条件概率。其基
Spark期末复习（五）Spark MLlib
wuwuwulalar的博客
06-22 479
Spark MLlib简介 算法与模型：没有经过数据训练之前的是算法，训练后的是模型 spark机器学习：突破传统机器学习算法的单机限制，使用分布式计算框架，对全局数据进行机器学习 MLlib库包括：分类、回归、聚类、协同过滤、降维 特征化工具：特征提取、转化、降维 机器学习不同的包： spark.mllib：基于RDD的数据抽象 spark.ml：基于DataFrame的数据抽象，可以将spark SQL与机器学习库融合，所以较为常用 机器学习流水线（pipeline） 一个比较完整
Spark-MLlib系列-上手小实验
Klingx的博客
06-10 1257
Spark-MLlib练习实验：基本概念-本地向量、转换器、评估器、参数
Spark-FpGrowth算法实现
鱼七
01-22 1244
Spark-FpGrowth算法实现
FP-Growth的spark实现算法
01-08
聚类分析常用算法FP-Growth的spark实现算法,
Spark mllib 线性回归测试数据
05-27
Spark mllib 线性回归算法测试数据
spark mllib机器学习之三 FPGrowth
深海小黄鱼
03-14 1142
数据格式： 苹果 梨 香蕉 梨 牛奶 土豆 苹果 香蕉 狗 狗 土豆 土豆 牛奶 盐 盐 梨 狗 苹果 梨 狗 package com.agm.guanlian import org.apache.spark.mllib.fpm.FPGrowth import org.apache.spark.{SparkConf, SparkContext} import ja
fpgrowth算法实战 mlib_Spark MLlib FPGrowth关联规则算法
weixin_42364392的博客
12-24 253
一.简介FPGrowth算法是关联分析算法，它采取如下分治策略：将提供频繁项集的数据库压缩到一棵频繁模式树(FP-tree)，但仍保留项集关联信息。在算法中使用了一种称为频繁模式树(Frequent Pattern Tree)的数据结构。FP-tree是一种特殊的前缀树，由频繁项头表和项前缀树构成。相关术语：1.项与项集这是一个集合的概念，以购物车为例，一件商品就是一项【item】，若干项的集合为...
spark FPGrowth笔记
u013303361的专栏
06-04 358
问题1：树深度无限制问题 这频繁项 子集深度不加限制，感觉不合理，，，好比词袋模型词袋任意长了；若不在前面手动限制 频繁项 最大长度，我的笔记本直接运行不出来，我的笔记本必须限制到30以内size(ids)<30。 问题2：参数含义setMinSupport(0.001) // 频繁项（热门商品）在总体的最小（出现）比例 追溯从fit到genericFit就发现minCount= math.ceil(minSupport * count)，再到genFreqItems发现解释为“m..
【机器学习系列2】FPGrowth算法与spark实现
安全曼巴2020
09-07 3454
原理 基础 支持度 支持度是指在所有项集中{X, Y}出现的可能性，即项集中同时含有X和Y的概率： 该指标作为建立强关联规则的第一个门槛，衡量了所考察关联规则在“量”上的多少。 置信度 置信度表示在先决条件X发生的条件下，关联结果Y发生的概率： 这是生成强关联规则的第二个门槛，衡量了所考察的关联规则在“质”上的可靠性。 提升度 提升度表示在含有X的条件下同时含有Y的可
基于Spark的FPGrowth（关联规则算法）
木东的博客
04-09 1899
转载请标明出处：小帆的帆的专栏 例子：  总共有10000个消费者购买了商品，  其中购买尿布的有1000人，  购买啤酒的有2000人，  购买面包的有500人，  同时购买尿布和啤酒的有800人，  同时购买尿布的面包的有100人。 关联规则 关联规则：用于表示数据内隐含的关联性，例如：购买尿布的人往往会购买啤酒。 支持度（support） 支持度：{
Spark MLlib FPGrowth算法
Spark MLlib 机器学习
05-09 1万+
1.1 FPGrowth算法 1.1.1 基本概念 关联规则挖掘的一个典型例子是购物篮分析。关联规则研究有助于发现交易数据库中不同商品（项）之间的联系，找出顾客购买行为模式，如购买了某一商品对购买其他商品的影响，分析结果可以应用于商品货架布局、货存安排以及根据购买模式对用户进行分类。 关联规则的相关术语如下： （1）项与项集 这是一个集合的概念，在一篮子商品中的一件消费品即为一项（Ite
基于用户的协同过滤算法的电影推荐系统
热门推荐
行者小朱的博客
08-21 4万+
上一篇讲解了推荐算法的分类，这里电影推荐系统具体分析一下 第一步：建立用户电影矩阵模型         如表1所示，协同过滤算法的输入数据通常表示为一个m*n的用户评价矩阵Matrix，m是用户数，n是电影数，Matrix[ij]表示第i个用户对第j个电影的评价： 第二步：发现兴趣相似的用户         这一阶段，主要完成对目标用户最近邻居的查找，通过计算目标用户与其他用户
如何基于Spark ML实现FP-growth算法
05-29
要基于Spark ML实现FP-growth算法，需要按照以下步骤： 1. 数据准备：将数据转换为适合FP-growth算法的格式，即将数据集转换为交易列表，其中每个交易是一个项集。 2. 构建模型：使用Spark ML的FP-growth实现构建模型。这个实现可以处理大规模数据集，并且可以设置最小支持度和最小置信度等参数。 3. 模型应用：使用模型对数据进行挖掘，从而得到频繁项集和关联规则。可以使用Spark SQL或DataFrame API来查询结果。 具体实现步骤可以参考以下代码： ```scala import org.apache.spark.ml.fpm.FPGrowth // 数据准备 val data = spark.read.textFile("path/to/data").map(line => line.split(" ")).toDF("items") // 构建模型 val fpGrowth = new FPGrowth().setItemsCol("items").setMinSupport(0.5).setMinConfidence(0.6) val model = fpGrowth.fit(data) // 模型应用 val freqItemsets = model.freqItemsets val associationRules = model.associationRules freqItemsets.show() associationRules.show() ``` 其中，`setItemsCol`指定项集列名，`setMinSupport`设置最小支持度，`setMinConfidence`设置最小置信度。`freqItemsets`和`associationRules`分别表示频繁项集和关联规则。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值