Spark Scala：如何使用rdd的每三个元素？

Question

大家。

我有这样的问题：

我有一个很大的rdd：数十亿个元素，例如：

Array[((Int, Int), Double)] = Array(((0,0),729.0), ((0,1),169.0), ((0,2),1.0), ((0,3),5.0), ...... ((34,45),34.0), .....)

我需要执行以下操作：

通过键(i,j)获取每个元素的值，然后将其添加到

min(rdd_value[(i-1, j)],rdd_value[(i, j-1)], rdd_value[(i-1, j-1)])

我怎样才能做到这一点，而无需使用collect()为后collect()我有Java memory errror我的RDD是非常大的。

非常感谢你！

我尝试从python实现此算法。 当时间序列为rdds时。

def DTWDistance(s1, s2):
    DTW={}

    for i in range(len(s1)):
        DTW[(i, -1)] = float('inf')
    for i in range(len(s2)):
        DTW[(-1, i)] = float('inf')
    DTW[(-1, -1)] = 0

    for i in range(len(s1)):
        for j in range(len(s2)):
            dist= (s1[i]-s2[j])**2
            DTW[(i, j)] = dist + min(DTW[(i-1, j)],DTW[(i, j-1)], DTW[(i-1, j-1)])

    return sqrt(DTW[len(s1)-1, len(s2)-1])

现在，我应该使用for循环执行最后一个操作。 dist已经计算。

例：

输入（如矩阵）：

4 5 1
7 2 3
9 0 1

Rdd看起来像

rdd.take(10)

Array(((1,1), 4), ((1,2), 5), ((1,3), 1), ((2,1), 7), ((2,2), 2), ((2,3), 3), ((3,1), 9), ((3,2), 0), ((3,3), 1))

我想做这个手术

rdd_value[(i, j)] = rdd_value[(i, j)] + min(rdd_value[(i-1, j)],rdd_value[(i, j-1)], rdd_value[(i-1, j-1)])

例如：

((1, 1), 4) = 4 + min(infinity, infinity, 0) = 4 + 0 = 4


4 5 1
7 2 3
9 0 1

然后

((1, 2), 5) = 5 + min(infinity, 4, infinity) = 5 + 4 = 9


4 9 1
7 2 3
9 0 1

然后

....

然后

((2, 2), 2) = 2 + min(7, 9, 4) = 2 + 4 = 6


4 9 1
7 6 3
9 0 1

然后 .....

((3, 3), 1) = 1 + min(3, 0, 2) = 1 + 0 = 1

Answer 1

一个简短的答案是，您尝试解决的问题无法使用Spark高效且简洁地表达。 如果选择普通RDD是分布式矩阵，则实际上并不重要。

要了解为什么您必须考虑Spark编程模型。 一个基本的Spark概念是一个依赖关系图，其中每个RDD都依赖一个或多个父RDD。 如果您的问题定义如下：

• 给定初始矩阵M ⁰
• 对于我<-1..n
  • 找出矩阵M ⁱ ，其中M ⁱ _（m，n） = M ^i-1 _（m，n） + min（M ^i-1 _{（m-1，n）} ，M ^i-1 _{（m-1，n-1）} ，M ^i-1 _{（m，n-1）} ）

那么使用Spark API（ 伪代码 ）表达将是微不足道的：

rdd
    .flatMap(lambda ((i, j), v): 
        [((i + 1, j), v), ((i, j + 1), v), ((i + 1, j + 1), v)])
    .reduceByKey(min)
    .union(rdd)
    .reduceByKey(add)

不幸的是，您试图表达同一数据结构中各个值之间的依赖性。 除了星火，这个问题很难并行化，更不用说分发了。

这种动态编程很难并行化，因为在不同点完全或几乎完全是顺序的。 例如，当您尝试计算M ⁱ _（0,0）或M ⁱ _{（m，n）时} ，没有什么可并行化的。 分发很困难，因为它会在块之间生成复杂的依赖关系。

在Spark中，可以通过计算单个块并表达这些块之间的依赖性或使用迭代算法并在显式图（GraphX）上传播消息的简单方法来处理此问题，但这并非易事。

归根结底，对于这种类型的计算，有一些工具比Spark更好。