L'exécution de la somme sur un rdd tableau int

Est-il intégré dans la transformation d'avoir la somme sur les Ints de suite ca

org.apache.spark.rdd.RDD[(String, (Int, Int))]

chaîne est la clé et Int tableau de la Valeur, ce dont j'ai besoin c'est d'avoir la somme de tous les Entiers comme RDD[(String, Int)] . J'ai essayé groupByKey sans succès...

Aussi - Le résultat doit être encore un rdd.

Merci d'avance

OriginalL'auteur Adam Right | 2015-04-08

  1. 5

    Si l'objectif est de faire la somme des éléments de valeur (Int, Int), puis une carte de transformation peut l'atteindre:

    val arr = Array(("A", (1, 1)), ("B", (2, 2)), ("C", (3, 3))

val rdd = sc.parallelize(arr)

val result = rdd.map{ case (a, (b, c)) => (a, b + c) }

//result.collect = Array((A,2), (B,4), (C,6))

    Plutôt si le type de valeur est un Tableau, Tableau.cette somme peut être utilisée.

    val rdd = sc.parallelize(Array(("A", Array(1, 1)), 
                               ("B", Array(2, 2)), 
                               ("C", Array(3, 3)))

rdd.map { case (a, b) => (a, b.sum) }

    Edit:

    map transformation ne pas garder l'original de partitionnement, comme @Justin suggéré mapValues peut être plus approprié ici:

    rdd.mapValues{ case (x, y) => x + y }
rdd.mapValues(_.sum)
    Je voudrais suggérer de changer ce mapValues de garder le hachage de la partition qui sera très probablement être mis en place
    est-il un moyen de le faire en Java?
    Note supplémentaire ) requis

    OriginalL'auteur Shyamendra Solanki

  2. 2

    Voici quelques façons d'pyspark.

    rdd = sc.parallelize([ ('A', (1,1)), ('B', (2,2)), ('C', (3, 3)) ])
rdd.mapValues(lambda (v1, v2): v1+v2).collect()

    Ou 

    >>> rdd.map(lambda (k, v): (k, sum(v))).collect()
[('A', 2), ('B', 4), ('C', 6)]

    Ou

    >>> rdd.map(lambda (k, v): (k, (v[0] + v[1]))).collect()
[('A', 2), ('B', 4), ('C', 6)]

    Ou

    >>> def fn(x):
...   k_s = (x[0], sum(x[1]))
...   print k_s
... 
>>> rdd.foreach(fn)
('C', 6)
('A', 2)
('B', 4)

    OriginalL'auteur Shiva