大数据Spark处理算法003-购物篮分析（MBA）

一前言

 目的：设定一个买东西的应用场景计算出如果购买了商品A，则购买商品B，的概率。A与B指一个或几个商品。

首先介绍俩个概念：

支持度（Support）：是指一个项集出现频度。如Support（{A，C}） =  2表示只在两次交易中商品A和C在一起出现。

置信度（Confidence）：关联规则左件和右件共同出现的频繁程度。

Support = （{A1，A2}）/  包含项目A1和A2的交易总次数

Confidence = （A1）/（A2）

二方案

测试数据：假设优四件商品（a，b，c，d）每一行代表一条交易记录

a,b,c
a,b,d
b,c
b,c

运用Spark解决方案：

1.首先用textFile读取文件生成JavaRDD。

2.然后将每一条交易（测试数据的每一行数据）分别排列组合，例如{a，b，c}则生成（[a]，1）（[b]，1）（[c]，1）（[a，b]，1）（[a，c]，1）（[b，c]，1）这样的JavaPairRDD。

3.reduceByKey聚合每一项的次数

4.拆分项目，如（[a，b]，2）则生成（[a，b]，（null，2））（[b]，（[a，b]，2））（[a]，（[a，b]，2））

5.groupByKey分组，以步骤4中的[a，b]、[b]、[a]分组

6.完成以上五步就找到了全部商品各种组合出现的次数并且数据格式为（[a，b]，（null，2））（（[a，b，d]，1））（（[a，b，c]，1））为空的是a和b一起出现的次数，那么以1/2就是如果购买了a和b也会买d或者c的概率。

三详细代码

执行代码的脚本：

/usr/local/spark1.5/bin/spark-submit \
--class cn.spark.study.core.FindAssociationRules \
--num-executors 3 \
--driver-memory 100m \
--executor-memory 100m \
--executor-cores 3 \
/usr/local/spark-text/java/mba/MBA.jar hdfs://spark01:9000/MBA/transactionsMBA.txt（上面的测试数据）

详细代码：

package cn.spark.study.core;

import java.util.ArrayList;
import java.util.List;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.PairFlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;

import cn.spark.study.util.Combination;
import scala.Tuple2;
import scala.Tuple3;

public class FindAssociationRules {

    public static void main(String[] args){
        
        SparkConf conf = new SparkConf().setAppName("FindAssociationRules");
        
        JavaSparkContext jsc = new JavaSparkContext(conf);
        
        if(args.length < 1){
            System.out.println("请在执行脚本写上参数");
            System.exit(1);
        }
        String transactionsFileName = args[0];
        
        JavaRDD<String> transactions = jsc.textFile(transactionsFileName);
        
        //生成频繁模式
        JavaPairRDD<List<String>,Integer> patterns = transactions.flatMapToPair(
                new PairFlatMapFunction<String,List<String>,Integer>(){

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Iterable<Tuple2<List<String>, Integer>> call(String transaction) throws Exception {
                        List<String> list = toList(transaction);
                        List<List<String>> combinations = Combination.findSortedCombinations(list);
                        
                        List<Tuple2<List<String>,Integer>> result = new ArrayList<Tuple2<List<String>,Integer>>();
                        for(List<String> combList : combinations){
                            if(combList.size() > 0 ){
                                result.add(new Tuple2<List<String>,Integer>(combList,1));
                            }
                        }
                        
                        return result;