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

Question

everyone.

I have such problem:

I have very big rdd: billions elements like:

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 need to do such operation:

take value of each element by key (i,j) and add to it the

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

How can I do this without using collect() as After collect() I have got Java memory errror as my rdd is very big.

Thank you very much!

I try to realize this algorithm from python. when time series are 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])

And now I should perform last operation with for loop. The dist is already calculated.

Example:

Input (like matrix):

4 5 1
7 2 3
9 0 1

Rdd looks like

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

I want to do this operation

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)])

For example:

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


4 5 1
7 2 3
9 0 1

Then

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


4 9 1
7 2 3
9 0 1

Then

....

Then

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


4 9 1
7 6 3
9 0 1

Then .....

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

Answer 1

A short answer is that the problem you try to solve cannot be efficiently and concisely expressed using Spark. It doesn't really matter if you choose plain RDDs are distributed matrices.

To understand why you'll have to think about the Spark programming model. A fundamental Spark concept is a graph of dependencies where each RDD depends on one or more parent RDDs. If your problem was defined as follows:

• given an initial matrix M ⁰
• for i <- 1..n
  • find matrix M ⁱ where 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) )

then it would be trivial to express using Spark API ( pseudocode ):

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)

Unfortunately you are trying to express dependencies between individual values in the same data structure. Spark aside it a problem which is much harder to parallelize not to mention distribute.

This type of dynamic programming is hard to parallelize because at different points is completely or almost completely sequential. When you try to compute for example M ⁱ _(0,0) or M ⁱ _(m,n) there is nothing to parallelize. It is hard to distribute because it can generate complex dependencies between blocks.

There are non trivial ways to handle this in Spark by computing individual blocks and expressing dependencies between these blocks or using iterative algorithms and propagating messages over the explicit graph (GraphX) but this is far from easy to do it right.

At the end of the day there tools which can be much better choice for this type of computations than Spark.