Spark Scala：如何处理rdd的每3个元素？

各位

我有这样的问题：

我有非常大的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内存错误

，因为我的rdd非常大

多谢各位

我试图从python实现这个算法。当时间序列是RDD时

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循环执行最后一个操作。距离已计算完毕

示例：

输入（如矩阵）：

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

然后

然后

然后

然后

---

简单的回答是，您试图解决的问题无法使用Spark高效、简洁地表达出来。如果您选择纯RDD作为分布式矩阵，这实际上并不重要

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

• 给定初始矩阵M0

---

• 对于我来说，一个简短的答案是，你试图解决的问题不能用Spark高效、简洁地表达出来。如果您选择纯RDD作为分布式矩阵，这实际上并不重要
  要理解为什么您必须考虑Spark编程模型。Spark的一个基本概念是依赖关系图，其中每个RDD依赖于一个或多个父RDD。如果您的问题定义如下：
  • 给定初始矩阵M0

  ---

  • 因为“行”长度是固定的吗？你说的行长度是什么意思？如果你只想用3个元素来获取最小值-是的。你的数据看起来像是一行接一行从矩阵拉出到向量。我说得对吗？如果是这样，我的问题是矩阵行的大小是多少？是的，正确！现在我有一个矩阵，行的长度约为10000，但在未来，长度将更大，每次都不同。还有，行数！=矩阵中的列数。看起来您正在尝试使用动态编程的某些变体。它不是可以使用RDDAPI高效简洁地实现的。尤其是Python程序按特定顺序执行更新，我们得到（i，j）状态（i-1，j），（i，j-1）和（i-1，j-1）已经在给定的迭代中更新。你可以很容易地应用矩阵MI到MJ的变换，其中MJ（i，j）是固定的“行”长度？行长度是什么意思？如果你只想用3个元素来获取最小值-是的。你的数据看起来像是一行接一行从矩阵拉出到向量。我说得对吗？如果是这样，我的问题是矩阵行的大小是多少？是的，正确！现在我有一个矩阵，行的长度约为10000，但在未来，长度将更大，每次都不同。还有，行数！=矩阵中的列数。看起来您正在尝试使用动态编程的某些变体。它不是可以使用RDDAPI高效简洁地实现的。尤其是Python程序按特定顺序执行更新，我们得到（i，j）状态（i-1，j），（i，j-1）和（i-1，j-1）已经在给定的迭代中更新。你可以很容易地应用从矩阵MI到MJ的变换，其中MJ（i，j）因此，我们不能在Spark中实现动态时间包装？@kinkajou不能很强，但即使你推导出一些用于利用分布式处理的近似值，它也不太可能是有用的和经济高效的。因此，我们无法在Spark中实现动态时间包装？@kinkajou可能不太强大，但即使您推导出一些旨在利用分布式处理的近似值，它也不太可能有用且具有成本效益。

    ((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
    

    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)