Question

我很难理解pyspark api中的笛卡儿方法。它在新的RDD中返回2 RDD的笛卡尔积。我想将这个方法应用于循环中的2 RDD（在固定的RDD上，另一个总是不同的，但总是具有相同的大小）。我不知道为什么在每次迭代时RDD的大小乘以第二个RDD的大小（就好像笛卡尔积与之前的结果一样堆叠）。这导致无限期执行和繁重的资源分配......

class MyClass(object):

    def __init__(self, sc, max_iter=100):
        self.spark = sc
        self.data = None
        self.max_iter = max_iter

    def calc(self, rdd):
        combinations = self.data.cartesian(rdd)\
            .map(lambda row: do_something(row))
        lists = combinations.reduceByKey(lambda x, y: x + y)
        res = lists.map(lambda row: do_something_else(row))
        return res

    def gen(self, rdd):
        return rdd.map(lambda row: do_something_again(row)).reduceByKey(lambda x, y: x + y)\
            .map(lambda row: do_a_last_thing(row))

    def run(self, rdd):
        self.data = rdd.persist()
        self.data.localCheckpoint()
        iteration = 0
        results = self.calc(rdd.takeSample(False, 3))
        while self.max_iter > iteration:
            tmp = gen(results)
            results = self.calc(tmp)
            iteration += 1
        return results.collect()

这个类在另一个python脚本中调用：

spark = SparkSession.builder.master("local").appName("test").getOrCreate()
test = MyClass(spark)
data = RandomRDDs.normalVectorRDD(spark, 10, 5, 3)
result = test.run(data)
print(result)

我不知道这是由于python类结构还是实现错误。我试图使固定的RDD持久化并创建一个本地检查点（如果它是由于谱系关系），但这些都不起作用。有人试过在循环中使用笛卡尔方法吗？

在固定的RDD上重复笛卡尔积

0 个答案: