转自：小帆的帆的专栏
例子：
总共有10000个消费者购买了商品，
其中购买尿布的有1000人，
购买啤酒的有2000人，
购买面包的有500人，
同时购买尿布和啤酒的有800人，
同时购买尿布的面包的有100人。
关联规则
关联规则：用于表示数据内隐含的关联性，例如：购买尿布的人往往会购买啤酒。
支持度（support）
支持度：{X, Y}同时出现的概率，例如：{尿布，啤酒}，{尿布，面包}同时出现的概率
{尿布，啤酒}的支持度 = 800 / 10000 = 0.08
{尿布，面包}的支持度 = 100 / 10000 = 0.01
注意：{尿布，啤酒}的支持度等于{啤酒，尿布}的支持度，支持度没有先后顺序之分
置信度（confidence）
置信度：购买X的人，同时购买Y的概率，例如：购买尿布的人，同时购买啤酒的概率，而这个概率就是购买尿布时购买啤酒的置信度
( 尿布 -> 啤酒 ) 的置信度 = 800 / 1000 = 0.8
( 啤酒 -> 尿布 ) 的置信度 = 800 / 2000 = 0.4
Spark计算支持度和置信度
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)
}
}" data-snippet-id="ext.11986a4eeb8ba67eb85edfbe6a9d224c" data-snippet-saved="false" data-codota-status="done">import org.apache.spark.sql.SQLContext
import 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
- 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
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
参考
本文的例子以及支持度，置信度的概念，总结自炼数成金-黄美灵老师的Spark MLlib 机器学习算法与源码解析课程课程文档。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
