关联规则、支持度（support）、置信度（confidence）、并运用Spark RDD计算

转载请标明出处：小帆的帆的专栏

例子：
总共有10000个消费者购买了商品，
其中购买尿布的有1000人，
购买啤酒的有2000人，
购买面包的有500人，
同时购买尿布和啤酒的有800人，
同时购买尿布的面包的有100人。

关联规则

关联规则：用于表示数据内隐含的关联性，例如：购买尿布的人往往会购买啤酒。

支持度（support）

支持度：{X, Y}同时出现的概率，例如：{尿布，啤酒}同时出现的概率

support=同时购买{X,Y}的人数总人数

{尿布，啤酒}的支持度 = 800 / 10000 = 0.08
{尿布，面包}的支持度 = 100 / 10000 = 0.01

注意：{尿布，啤酒}的支持度等于{啤酒，尿布}的支持度，支持度没有先后顺序之分

置信度（confidence）

置信度：购买X的人，同时购买Y的概率，例如：购买尿布的人，同时购买啤酒的概率，而这个概率就是购买尿布时购买啤酒的置信度

confidence（X−>Y）=同时购买{X,Y}的人数购买X的人数

confidence（Y−>X）=同时购买{X,Y}的人数购买Y的人数

( 尿布 -> 啤酒 ) 的置信度 = 800 / 1000 = 0.8
( 啤酒 -> 尿布 ) 的置信度 = 800 / 2000 = 0.4

Spark计算支持度和置信度

import org.apache.spark.sql.SQLContextimport org.apache.spark.{SparkConf, SparkContext}object Test {  def main(args: Array[String]) {    val conf = new SparkConf().setAppName("Test").setMaster("local")    val sc = new SparkContext(conf)    val sqlContext = new SQLContext(sc)    // 测试数据， 为方便分析问题    // 左边一列是用户，有三个用户a,b,c    // 右边一列是公司，表示用户喜欢的公司    val testData = Array(      ("a", "google"),      ("a", "apple"),      ("a", "mi"),      ("b", "google"),      ("b", "apple"),      ("c", "google")    )    val data = sc.parallelize(testData)    // 最终我们要构造出这样的结果：公司A、公司B、支持度、A->B的置信度、B->A的置信度    // 要求支持度和置信度就需要三个值，喜欢A公司的人数，喜欢B公司的人数，同时喜欢A和B公司的人数    // 我们先求前两个    val companyCountRDD = data.map(a => (a._2, 1)).reduceByKey(_ + _)    /**      * (mi,1)      * (google,3)      * (apple,2)      */    companyCountRDD.collect().foreach(println)    // 要计算同时喜欢A和B公司的人数，要先知道A，B所有可能的组合    // 比如：1， 2， 3,；所有可能的组合就是（1,2）,（1,3）,（2,3）    // 这里我们简单的用cartesian算子实现    // cartesian算子会得到这样的结果：    // （1,1），（1,2），（1,3），    // （2,1），（2,2），（2,3），    // （3,1），（3,2），（3,3）    // 然后filter算子，只保留左边大于右边的结果，这样能过滤掉相等的结果，如（1,1），还有重复的结果，如（2,1），因为我们已经有（1,2）了    val cartesianRDD = companyCountRDD.cartesian(companyCountRDD).filter(tuple => tuple._1._1 > tuple._2._1).map(t => ((t._1._1, t._2._1), (t._1._2, t._2._2)))    // 这样我们不但得到了A和B的所有组合，还顺带聚合了计算用的到的数据    /** 公司A、公司B、喜欢A公司的人数、喜欢B公司的人数      * ((mi,google),(1,3))      * ((mi,apple),(1,2))      * ((google,apple),(3,2))      */    cartesianRDD.collect().foreach(println)    // 下面开始计算，同时喜欢A和B公司的人数    // 比如a这个人，它喜欢google,apple,mi; 那么就是同时喜欢(mi,google)，(mi,apple)，(google,apple)    // 所以我们先要将数据转换成(a, (google,apple,mi))    // 这个时候用户就没用了，我们只需要知道公司的组合    // 因此转换成(mi,google)，(mi,apple)，(google,apple)    // 最后用flatMap将结果打散，再计数    val userCompaniesRDD = data.groupByKey().cache()    val meanwhileRDD = userCompaniesRDD.map(_._2)      // 这里采用了类似cartesian的做法计算所有的组合，然后过滤掉不需要的      .flatMap(iter => iter.flatMap(i => iter.map(j => (i, j))).filter(tuple => tuple._1 > tuple._2))      .map(tuple => (tuple, 1))      .reduceByKey(_ + _)    // 计算用户总数，后面会用到    val userNum = userCompaniesRDD.count()    /** 公司A、公司B、同时喜欢A和B公司的人数      * ((mi,apple),1)      * ((mi,google),1)      * ((google,apple),2)      */    meanwhileRDD.collect().foreach(println)    val calRDD = cartesianRDD.join(meanwhileRDD)    /** 公司A、公司B、喜欢A公司的人数，喜欢B公司的人数，同时喜欢A和B公司的人数      * ((mi,apple),((1,2),1))      * ((mi,google),((1,3),1))      * ((google,apple),((3,2),2))      */    calRDD.collect.foreach(println)    // 计算结果    val resultRDD = calRDD.map(t => {      val aCompany = t._1._1      val bCompany = t._1._2      val aCount = t._2._1._1      val bCount = t._2._1._2      val aAndbCount = t._2._2 * 1.0      // 公司A、公司B、支持度、A->B的置信度、B->A的置信度      (aCompany, bCompany, aAndbCount / userNum, aAndbCount / aCount, aAndbCount / bCount)    })    /**      * (mi,apple,0.3333333333333333,1.0,0.5)      * (mi,google,0.3333333333333333,1.0,0.3333333333333333)      * (google,apple,0.6666666666666666,0.6666666666666666,1.0)      */    resultRDD.collect.foreach(println)    // 最后可以过滤掉数值太低的    // 支持度的阈值是1%，置信度阈值50%    val support = 0.01    val confidence = 0.5    resultRDD.filter(a => a._3 > support && a._4 > confidence && a._5 > confidence).collect().foreach(println)  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

注意：cartesian这个算子很恐怖，如果要追求性能的话，还是要自己写一个算法

参考

本文的例子以及支持度，置信度的概念，总结自炼数成金-黄美灵老师的Spark MLlib 机器学习算法与源码解析课程课程文档