FP-Growth in Spark MLLib
并行FP-Growth算法思路
上图的单线程形成的FP-Tree。
分布式算法事实上是对FP-Tree进行分割,分而治之
首先,假设我们只关心...|c这个conditional transaction,那么可以把每个transaction中的...|c保留,并发送到一个计算节点中,必然能在该计算节点构造出FG-Tree
root
| \
f:3 c:1
|
c:3
进而得到频繁集(f,c)->3.
同样,如果把所有transaction中的...|b保留,并发送到一个计算节点中,必然能在该几点构造出FG-tree
root
/ \
f:2 c:1
| \ \
c:1 b:1 b:1
|
a:1
|
b:1
进而得到(b)->3。
以上两个例子得到了两个tree,并且分别得到了部分结果。
事实上算法的思路就是把transaction的conditional transaction进行分割(分组),分割的依据就是conditional transaction的suffix(的hash,如果直接是suffix也可以,但是使得spark任务有过多task)。对每个分组分别构建FP-tree,然后在每个子树中获得部分结果,合并得到最终结果。
Spark Mllib中算法
遍历一次数据集输出F-List,类似wordcount,得出频繁出现的items,将F-List划分为G-List,即将频繁items进行分组:
- F-List包含item全集I中的频繁item,F-List={f_1,...},f_i在Transaction中出现的频率>support阈值。
- G-List={g_1,...}, g_i=hash_of(f_i)=H(f_i).
![](http://latex.codecogs.com/svg.latex?H:item_i->g_{j}\ hashvalue\ of\ f_i)
实际上,计算的f_i hash值作为partition_id,在MLLib过程中将conditional transaction f'1,f'2,...|f_i 分发到partition_id=H(f_i)对应的计算节点。
// data即所有的transaction,每个trans是Item数组
def run[Item: ClassTag](data: RDD[Array[Item]]): FPGrowthModel[Item] = {
// 计算support阈值
val count = data.count()
val minCount = math.ceil(minSupport * count).toLong
val numParts = if (numPartitions > 0) numPartitions else data.partitions.length
val partitioner = new HashPartitioner(numParts)
// 第一次遍历,统计frequency,过滤掉低于support阈值的item
val freqItems:Array[Item] = genFreqItems(data, minCount, partitioner)
// 第二次遍历
val freqItemsets = genFreqItemsets(data, minCount, freqItems, partitioner)
new FPGrowthModel(freqItemsets)
}
各组构建FP-tree
再次遍历数据集,每个trans中的items按照frequency进行降序排列,并构造conditional transactions,例如一个trans={a,b,c,d,e},a的frequency最高,以此降低,构造其相应的conditional transactions:
a,b,c,d,e:
condition trans ; partition_id
a,b,c,d|e ; partition = H(e)
a,b,c|d ; partition = H(d)
a,b|c ; partition = H(c)
a|b ; partition = H(b)
a ; partition = H(a)
对应code在genFreqItemsets
.
- 每个transaction的conditional transaction,并且按照suffix计算hash作为partition_id分组
- 各个partition_id对应的[condition items]所有集合,即G-List,对G-List的agg即为构造FP-Tree过程
- 在各个part中提取该part包含的频繁集。在part子树中,node x,若hash(x)=part_id,并且x到root路径能形成频繁集,则输出path(x->root)中的各个节点作为频繁集。
- 将rank转为对应的item
private def genFreqItemsets[Item: ClassTag](
data: RDD[Array[Item]], // transactions
minCount: Long, // support threshold
freqItems: Array[Item], // FP-List
partitioner: Partitioner): RDD[FreqItemset[Item]] = {
// freqItems已经排序了,zip出每个Item的rank
val itemToRank = freqItems.zipWithIndex.toMap
// 形成partition_id->[condition items]
data.flatMap { transaction =>
// 计算conditional transactions
genCondTransactions(transaction, itemToRank, partitioner)
}
// 各个partition_id对应的[condition items]所有集合,即G-List,
// 对G-List的agg即为构造FP-Tree过程
.aggregateByKey(new FPTree[Int], partitioner.numPartitions)(
(tree, transaction) => tree.add(transaction, 1L),
(tree1, tree2) => tree1.merge(tree2))
// 在各个part中提取该part包含的频繁集
.flatMap { case (part, tree) =>
tree.extract(minCount, x => partitioner.getPartition(x) == part)
}
// 将rank转为对应的item
.map { case (ranks, count) =>
new FreqItemset(ranks.map(i => freqItems(i)).toArray, count)
}
}
计算conditional transactions
- itemToRank,rank越小对应的frequency是越大的
- 每个trans中筛出frequent Item,并对rank排序,得到的item即按照frequency由大到小排序
- FP_list=
- 一个trans=[f,e,d,a,c], 那么将得到[0,2,3,4,5]
- 构造conditional transaction
- 例如0,2|3 计算3的partition_id(3), 形成partition_id(3)->[0,2,3]
private def genCondTransactions[Item: ClassTag](
transaction: Array[Item],
itemToRank: Map[Item, Int],
partitioner: Partitioner): mutable.Map[Int, Array[Int]] = {
val output = mutable.Map.empty[Int, Array[Int]]
// Filter the basket by frequent items pattern and sort their ranks.
val filtered = transaction.flatMap(itemToRank.get)
ju.Arrays.sort(filtered)
val n = filtered.length
var i = n - 1
while (i >= 0) {
val item = filtered(i)
val part = partitioner.getPartition(item)
if (!output.contains(part)) {
output(part) = filtered.slice(0, i + 1)
}
i -= 1
}
output
}