Apache spark 火花加速笛卡尔积

有没有合适的方法来加速两个数据集之间的笛卡尔乘积？我使用的是一个350k元素的数据集，我想得到它的组合（n取2）

我使用经典策略在Spark中查找2个组合：

words_comb = dataset.cartesian(dataset).filter(lambda x: x[0] < x[1])

words\u comb=dataset.cartesian（数据集）.filter（lambda x:x[0]

我使用的是Databricks框架，需要45分钟以上才能完成（45分钟后，spark驱动程序在Databricks中停止…）。我们都同意这样一个事实，即在这个特定问题上的瓶颈是数据集的笛卡尔积，其时间复杂度为O（n^2）

有没有办法改善这一点？有没有更好的办法解决这个问题

（谢谢）

我需要建立一个图G=（N，F），其中F（N）是一个函数，它的图像是单词S的子集S，这些单词的编辑距离（N，S）=1。为了做到这一点，我从所有的单词组合开始，然后依次过滤所有不符合编辑距离=1的约束条件的单词对

你的方法效率低得可笑。对于平均长度为n个字的字符串，s或多或少为O（n2 s2）（n2

edit_distance

calls）。同时，您的数据很小（根据标准为4.1MB），分布式处理及其开销不是很有用。你应该重新考虑你的方法

我的建议是使用高效的查找结构（例如or），它可以促进对不匹配的高效搜索。使用整个数据集构建索引，如果需要，使用线程来并行搜索

It's possible to get rid of Cartesian product, without using a special data structure.

I will demonstrate the method by an example with pyspark

Suppose you have a data set of (user, query).

input:

users_queries_rdd = sc.parallelize([
     ('u1', 'q1'), ('u1', 'q2'), ('u1', 'q3'), ('u1', 'q4'),
     ('u2', 'q2'), ('u2', 'q4'), ('u2', 'q5'),
     ('u3', 'q1'), ('u3', 'q2'), ('u3', 'q4')
 ])

You would like to count the occurrences of 2 queries for different users.

expected output:
[(('q4', 'q2'), 3),
 (('q5', 'q2'), 1),
 (('q3', 'q1'), 1),
 (('q5', 'q4'), 1),
 (('q4', 'q1'), 2),
 (('q3', 'q2'), 1),
 (('q2', 'q1'), 2),
 (('q4', 'q3'), 1)]

我需要建立一个图G=（N，F），其中F（N）是一个函数，它的图像是单词S的子集S，这些单词的编辑距离（N，S）=1。为了做到这一点，我从所有的单词组合开始，然后依次过滤所有不符合编辑距离=1的约束条件的单词对

你的方法效率低得可笑。对于平均长度为n个字的字符串，s或多或少为O（n2 s2）（n2

edit_distance

calls）。同时，您的数据很小（根据标准为4.1MB），分布式处理及其开销不是很有用。你应该重新考虑你的方法

我的建议是使用高效的查找结构（例如or），它可以促进对不匹配的高效搜索。使用整个数据集构建索引，如果需要，使用线程来并行搜索

It's possible to get rid of Cartesian product, without using a special data structure.

I will demonstrate the method by an example with pyspark

Suppose you have a data set of (user, query).

input:

users_queries_rdd = sc.parallelize([
     ('u1', 'q1'), ('u1', 'q2'), ('u1', 'q3'), ('u1', 'q4'),
     ('u2', 'q2'), ('u2', 'q4'), ('u2', 'q5'),
     ('u3', 'q1'), ('u3', 'q2'), ('u3', 'q4')
 ])

You would like to count the occurrences of 2 queries for different users.

expected output:
[(('q4', 'q2'), 3),
 (('q5', 'q2'), 1),
 (('q3', 'q1'), 1),
 (('q5', 'q4'), 1),
 (('q4', 'q1'), 2),
 (('q3', 'q2'), 1),
 (('q2', 'q1'), 2),
 (('q4', 'q3'), 1)]

方法1-使用笛卡尔积： 方法2-去除笛卡尔积： 说明： 方法1： 1.1.笛卡尔（用户查询）
在rdd与自身之间创建笛卡尔乘积。 它生成n^2个组合

1.2.过滤器（lambda行：行[0]>行[1]）
如果包含（q1，q2），那么（q2，q1）将被过滤掉

1.3.过滤器（lambda行：行[0][0]==行[1][0]）
按用户分组查询（聚合）

1.4.地图（lambda线：（线[0][1]，线[1][1]））
省略用户列。只保留查询对

1.5.地图（lambda线：（线，1））
将每一行的（q[i]，q[j]）映射到（（q[i]，q[j]），1）

1.6.还原基（添加）
计算每个查询对的出现次数

方法2： 2.1.地图（λ线：（线[0]，[线[1]]）
将每一行的（u[i]，q[j]）映射到（u[i]，[q[j]]）（查询被封装到一个列表中）

2.2.还原基（添加）
为每个用户创建一个包含其所有查询的列表

2.3.映射（lambda行：元组（组合（行[1]，2]））
对于每个用户，省略用户列，并创建其所有查询的组合

2.4.平面图（λ线：[（x，1）表示x线]）
展平贴图将展平所有映射到（（q[i]，q[j]），1）的键：（q[i]，q[j]）

2.5.还原基（添加）
计算每个查询对的出现次数

我们假设每个用户的查询数量相对较小（一个常量）。 因此，方法2的效率为O（n）

由于每个用户都使用iter.combinations函数，这一假设是必要的

在大多数实际情况下，方法2更有效

方法1-使用笛卡尔积： 方法2-去除笛卡尔积： 说明： 方法1： 1.1.笛卡尔（用户查询）
在rdd与自身之间创建笛卡尔乘积。 它生成n^2个组合

1.2.过滤器（lambda行：行[0]>行[1]）
如果包含（q1，q2），那么（q2，q1）将被过滤掉

1.3.过滤器（lambda行：行[0][0]==行[1][0]）
按用户分组查询（聚合）

1.4.地图（lambda线：（线[0][1]，线[1][1]））
省略用户列。只保留查询对

1.5.地图（lambda线：（线，1））
将每一行的（q[i]，q[j]）映射到（（q[i]，q[j]），1）

1.6.还原基（添加）
计算每个查询对的出现次数

方法2： 2.1.地图（λ线：（线[0]，[线[1]]）
将每一行的（u[i]，q[j]）映射到（u[i]，[q[j]]）（查询被封装到一个列表中）

2.2.还原基（添加）
为每个用户创建一个包含其所有查询的列表

2.3.映射（lambda行：元组（组合（行[1]，2]））
对于每个用户，省略用户列，并创建其所有查询的组合

2.4.平面图（λ线：[（x，1）表示x线]）
展平贴图将展平所有映射到（（q[i]，q[j]），1）的键：（q[i]，q[j]）

2.5.还原基（添加）
计算每个查询对的出现次数

我们假设每个用户的查询数量相对较小（一个常量）。 因此，方法2的效率为O（n）

由于每个用户都使用iter.combinations函数，这一假设是必要的

---

在大多数实际情况下，方法2更有效。

在databricks论坛上有一个可以帮助您的方法。@Jeremy谢谢。问题将是O（n^2）无所谓

pair_queries_count_rdd_no_cartesian = users_queries_rdd\
                        .map(lambda line: (line[0], [line[1]]))\
                        .reduceByKey(add)\
                        .map(lambda line: tuple(combinations(line[1], 2)))\
                        .flatMap(lambda line: [(x, 1) for x in line])\
                        .reduceByKey(add)