Spark FPGrowth关联规则算法

最新推荐文章于 2021-01-29 10:12:22 发布

weixin_33895016

最新推荐文章于 2021-01-29 10:12:22 发布

阅读量347

点赞数

文章标签：大数据 scala java

原文链接：https://my.oschina.net/penngo/blog/3020588

版权

为什么80%的码农都做不了架构师？>>>

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的概率；

package com.penngo.spark.ml.main;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.spark.ml.fpm.FPGrowth;
import org.apache.spark.ml.fpm.FPGrowthModel;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.*;
import java.util.Arrays;
import java.util.List;

/**
 * 
 */
public class JavaFPGrowthExample {
    public static void main(String[] args) {
        System.setProperty("hadoop.home.dir", "D:/hadoop/hadoop-2.7.6");
        System.setProperty("HADOOP_USER_NAME", "root");
        Logger.getLogger("org.apache.spark").setLevel(Level.WARN);
        Logger.getLogger("org.apache.eclipse.jetty.server").setLevel(Level.OFF);
        SparkSession spark = SparkSession
                .builder()
                .appName("JavaFPGrowthExample").master("local[3]")
                .getOrCreate();

        // $example on$
        List<Row> data = Arrays.asList(
                RowFactory.create("1", Arrays.asList("牛奶,鸡蛋,面包,薯片".split(","))),
                RowFactory.create("2", Arrays.asList("鸡蛋,爆米花,薯片,啤酒".split(","))),
                RowFactory.create("3", Arrays.asList("鸡蛋,面包,薯片".split(","))),
                RowFactory.create("4", Arrays.asList("牛奶,鸡蛋,面包,爆米花,薯片,啤酒".split(","))),
                RowFactory.create("5", Arrays.asList("牛奶,面包,啤酒".split(","))),
                RowFactory.create("6", Arrays.asList("鸡蛋,面包,啤酒".split(","))),
                RowFactory.create("7", Arrays.asList("牛奶,面包,薯片".split(","))),
                RowFactory.create("8", Arrays.asList("牛奶,鸡蛋,面包,黄油,薯片".split(","))),
                RowFactory.create("9", Arrays.asList("牛奶,鸡蛋,黄油,薯片".split(",")))
        );
        StructType schema = new StructType(new StructField[]{
                new StructField("user", DataTypes.StringType, false, Metadata.empty()),
                new StructField("items", new ArrayType(DataTypes.StringType, true), false, Metadata.empty())}
        );
        Dataset<Row> itemsDF = spark.createDataFrame(data, schema);
        itemsDF.show();
        FPGrowthModel model = new FPGrowth()
                .setItemsCol("items")
                .setMinSupport(0.5)    //最小支持度
                .setMinConfidence(0.6) //最小置信度
                .fit(itemsDF);

        // 显示数据出现次数
        model.freqItemsets().show();

        // 显示生成的关联规则
        //antecedent表示前项
        //consequent表示后项
        //confidence表示规则的置信度
        model.associationRules().show();
//        model.associationRules().collectAsList().forEach(row->{
//            System.out.println(
//                    scala.collection.JavaConversions.seqAsJavaList(row.getAs("antecedent")) + ", "
//                    + scala.collection.JavaConversions.seqAsJavaList(row.getAs("consequent")) + ", "
//                    + row.getAs("confidence"));
//        });

        // 重新检查所有关联规则和预测结果的输入项。
        model.transform(itemsDF).show();
//        model.transform(itemsDF).collectAsList().forEach(row->{
//            System.out.println(
//                    scala.collection.JavaConversions.seqAsJavaList(row.getAs("items")) + ", "
//                    + scala.collection.JavaConversions.seqAsJavaList(row.getAs("prediction")));
//        });

        spark.stop();
    }
}

用户购买物品
+----+--------------------+
|user| items|
+----+--------------------+
| 1| [牛奶, 鸡蛋, 面包, 薯片]|
| 2| [鸡蛋, 爆米花, 薯片, 啤酒]|
| 3| [鸡蛋, 面包, 薯片]|
| 4|[牛奶, 鸡蛋, 面包, 爆米花,...|
| 5| [牛奶, 面包, 啤酒]|
| 6| [鸡蛋, 面包, 啤酒]|
| 7| [牛奶, 面包, 薯片]|
| 8|[牛奶, 鸡蛋, 面包, 黄油, 薯片]|
| 9| [牛奶, 鸡蛋, 黄油, 薯片]|
+----+--------------------+

+--------+----+
| 物品 | 出现次数|
+--------+----+
| [牛奶]| 6|
|[牛奶, 面包]| 5|
|[牛奶, 薯片]| 5|
| [鸡蛋]| 7|
| [薯片]| 7|
|[薯片, 鸡蛋]| 6|
| [面包]| 7|
|[面包, 薯片]| 5|
|[面包, 鸡蛋]| 5|
+--------+----+

购买的支持度计算，
购买物品1的人中同时购买物品1、2的支持度计算（物品1、2同时出现次数/物品1出现次数）
支持度：在所有购买人中，同时购买牛奶和面包的支持度:5/9
置信度: 购买牛奶的人中，也购买面包的概率：5/6=0.8333333333333334
提升度：购买了牛奶的人也购买了面包的概率与所有人中购买了面包的人概率的概率（5/6）/（7/9）
通过支持度和置信度可以得出强关联关系，通过提升的，可判别有效的强关联关系。

+----------+----------+------------------+
|antecedent|consequent| confidence|
+----------+----------+------------------+
| [牛奶]| [面包]|0.8333333333333334|
| [牛奶]| [薯片]|0.8333333333333334|
| [鸡蛋]| [薯片]|0.8571428571428571|
| [鸡蛋]| [面包]|0.7142857142857143|
| [面包]| [牛奶]|0.7142857142857143|
| [面包]| [薯片]|0.7142857142857143|
| [面包]| [鸡蛋]|0.7142857142857143|
| [薯片]| [牛奶]|0.7142857142857143|
| [薯片]| [鸡蛋]|0.8571428571428571|
| [薯片]| [面包]|0.7142857142857143|
+----------+----------+------------------+

按支持度大于0.5，置信度大于0.6预测用户还可能购买的物品
+----+--------------------+----------+
|user| items|prediction|
+----+--------------------+----------+
| 1| [牛奶, 鸡蛋, 面包, 薯片]| []|
| 2| [鸡蛋, 爆米花, 薯片, 啤酒]| [面包, 牛奶]|
| 3| [鸡蛋, 面包, 薯片]| [牛奶]|
| 4|[牛奶, 鸡蛋, 面包, 爆米花,...| []|
| 5| [牛奶, 面包, 啤酒]| [薯片, 鸡蛋]|
| 6| [鸡蛋, 面包, 啤酒]| [薯片, 牛奶]|
| 7| [牛奶, 面包, 薯片]| [鸡蛋]|
| 8|[牛奶, 鸡蛋, 面包, 黄油, 薯片]| []|
| 9| [牛奶, 鸡蛋, 黄油, 薯片]| [面包]|
+----+--------------------+----------+