[Spark购物篮的关联规则实现]

       购物篮分析（Market Basket Analysis，MBA）是一个商品交易中流行的数据挖掘技术，市场营销人员和电子商务人员经常用这个技术来揭示不同商品或商品组合之间的相似度。商品数据挖掘的目标，一般是从庞大的数据集合中提取有趣及有用的关联信息，例如数前千万商品或信用卡销售交易。购物篮分析可以帮助分析人员找出很有可能一起购买的商品，关联规则挖掘则会发现一个交易商品之间的相关性。然后市场销售人员可以使用这些关联规则在商店货架上或者在线将相关的商品摆放在相邻的位置，使顾客更加方便的购买自己想要的商品。

购物篮目标

       通过一组交易数据中，挖掘出最频繁数据项集Fi(i=1,2,3…)，可以使用这组频繁交易数据项生成交易的一个组合关联规则。在数据挖掘中，关联规则有两个重要的度量标准：

支持度(Support)

       一个项集的出现的频度。例如，Support({A,C})=2，表示项A和项C只在两个交易中一起出现。

置信度(Confidence)

       关联规则左件与右件共同出现的频繁程度。

       利用购物篮的关联规则分析，可以为销售人员提供购物者的潜在购物行为：

        1.     哪些商品会一起够爱？

        2.     每个每个购物篮里有哪些商品？

        3.     哪些商品应当降价销售？

        4.     商品应当如何相邻摆放可以实现最大利润？

        5.     如何确定电子商务网站的商品目录？

购物篮分析的应用领域

       购物篮分子适用于超市的购物者。在许多其他的领域中也可以应用购物篮分析。包括：

        1.     信用卡交易分析。

        2.     电话呼叫模式分析。

        3.     医疗保险欺诈识别。

        4.     电信服务交易分析。

        5.     大型在线零售商的每日/周/月的交易分析。

使用Spark实现购物篮的关联规则分析

测试数据

        每一行代表一条交易数据。如下所示：

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

Spark的实现

 实现流程

      Spark的关联规则算法，采用两阶段的MapReduce算法：

     1、 MapReducej阶段1：交易转换模式并找出频繁模式，其流程图如下所示：

    2、 MapReducej阶段2：生成关联规则，其流程图如下所示：

 代码实现

/**
  * Spark购物篮关联规则算法
  **/
object FindAssociationRules {
    def main(args: Array[String]): Unit = {
        if (args.length < 2) {
            println("Usage: FindAssociationRules <input-path> <output-path>")
            sys.exit(1)
        }
        val inputPath = args(0)
        val outputPath = args(1)

        val sparkConf: SparkConf = new SparkConf()
            .setMaster("local[2]")
            .setAppName("spark-market-basket-analysis")
        val sc: SparkContext = SparkContext.getOrCreate(sparkConf)

        val transactions: RDD[String] = sc.textFile(inputPath)

        val patterns: RDD[(List[String], Int)] = transactions.flatMap(line => {
            val items = line.split(",").toList
            (0 to items.size).flatMap(items.combinations).filter(xs => !xs.isEmpty)
        }).map((_, 1))

        //商品组合出现的频度计算
        val combined: RDD[(List[String], Int)] = patterns.reduceByKey(_ + _)

        val subpatterns: RDD[(List[String], (List[String], Int))] = combined.flatMap(pattern => {
            val result = ListBuffer.empty[Tuple2[List[String], Tuple2[List[String], Int]]]
            result += ((pattern._1, (Nil, pattern._2)))

            val sublist = for {
                i <- 0 until pattern._1.size
                xs = pattern._1.take(i) ++ pattern._1.drop(i + 1)
                if xs.size > 0
            } yield (xs, (pattern._1, pattern._2))
            result ++= sublist
            result.toList
        })

        val rules: RDD[(List[String], Iterable[(List[String], Int)])] = subpatterns.groupByKey()

        val assocRules: RDD[List[(List[String], List[String], Double)]] = rules.map(in => {
            val fromCount = in._2.find(p => p._1 == Nil).get
            val lstData = in._2.filter(p => p._1 != Nil).toList
            if (lstData.isEmpty) Nil
            else {
                val result = {
                    for {
                        t2 <- lstData
                        confidence = t2._2.toDouble / fromCount._2.toDouble
                        difference = t2._1 diff in._1
                    } yield (((in._1, difference, confidence)))
                }
                result
            }
        })

        val formatResult: RDD[(String, String, Double)] = assocRules.flatMap(f => {
            f.map(s => (s._1.mkString("[", ",", "]"), s._2.mkString("[", ",", "]"), s._3))
        }).sortBy(tuple => tuple._3, false, 1)
        //保存结果
        //formatResult.saveAsTextFile(outputPath)

        //打印商品组合频度
        combined.foreach(println)
        //打印商品关联规则和置信度
        formatResult.foreach(println)
        sc.stop()
    }
}

运行结果

频繁项结果

(List(b, d, e),1)
(List(a, b, c),1)
(List(c, e),2) 
(List(e),5)
(List(b),9)
(List(c, d, e),1)
(List(d, e),2)
(List(b, c, e),1)
(List(b, c, d),1)
(List(c, d),2)
(List(a),6)
(List(a, b, d),1)
(List(b, c),3)
(List(b, d),5)
(List(a, c),2)
(List(a, b),3)
(List(d),7)
(List(b, e),3)
(List(a, e),1)
(List(a, d),2)
(List(c),5)

关联规则结果

([d],[b],0.7142857142857143)
([e],[b],0.6)
([c],[b],0.6)
([b],[d],0.5555555555555556)
([c,e],[d],0.5)
([c,e],[b],0.5)
([d,e],[b],0.5)
([d,e],[c],0.5)
([a],[b],0.5)
([a,c],[b],0.5)
([c,d],[b],0.5)
([c,d],[e],0.5)
([a,d],[b],0.5)
([e],[c],0.4)
([e],[d],0.4)
([c],[e],0.4)
([c],[a],0.4)
([c],[d],0.4)
([b],[c],0.3333333333333333)
([b],[a],0.3333333333333333)
([b],[e],0.3333333333333333)
([a],[c],0.3333333333333333)
([a],[d],0.3333333333333333)
([b,c],[d],0.3333333333333333)
([b,c],[a],0.3333333333333333)
([b,c],[e],0.3333333333333333)
([a,b],[c],0.3333333333333333)
([a,b],[d],0.3333333333333333)
([b,e],[d],0.3333333333333333)
([b,e],[c],0.3333333333333333)
([d],[e],0.2857142857142857)
([d],[c],0.2857142857142857)
([d],[a],0.2857142857142857)
([e],[a],0.2)
([b,d],[e],0.2)
([b,d],[c],0.2)
([b,d],[a],0.2)
([a],[e],0.16666666666666666)