Spark différence entre reduceByKey vs groupByKey vs aggregateByKey vs combineByKey

Question

Quelqu'un peut-il expliquer la différence entre reducebykey,groupbykey,aggregatebykey et combinebykey? J'ai lu les documents à ce sujet , mais je ne pouvais pas comprendre les différences exactes?

Si vous pouvez l'expliquer avec des exemples, ce serait formidable.

Answer 1

groupByKey:

Syntaxe:

sparkContext.textFile("hdfs://")
                    .flatMap(line => line.split(" ") )
                    .map(word => (word,1))
                    .groupByKey()
                    .map((x,y) => (x,sum(y)) )

groupByKey peut causer des problèmes de disque que les données sont envoyées sur le réseau et recueillies sur l'réduire les travailleurs.

reduceByKey:

Syntaxe:

sparkContext.textFile("hdfs://")
                    .flatMap(line => line.split(" "))
                    .map(word => (word,1))
                    .reduceByKey((x,y)=> (x+y))

Les données sont combinées à chaque partition , une seule sortie pour une touche à chaque partition à envoyer sur le réseau. reduceByKey nécessaire de combiner toutes vos valeurs en une autre valeur, avec exactement le même type.

aggregateByKey:

même que reduceByKey, qui prend une valeur initiale.

3 paramètres en entrée j'. valeur initiale ii. Combinateurs de la logique iii. séquence op logique

*Example:* `

val keysWithValuesList = Array("foo=A", "foo=A", "foo=A", "foo=A", "foo=B", "bar=C", "bar=D", "bar=D")
    val data = sc.parallelize(keysWithValuesList)
    //Create key value pairs
    val kv = data.map(_.split("=")).map(v => (v(0), v(1))).cache()
    val initialCount = 0;
    val addToCounts = (n: Int, v: String) => n + 1
    val sumPartitionCounts = (p1: Int, p2: Int) => p1 + p2
    val countByKey = kv.aggregateByKey(initialCount)(addToCounts, sumPartitionCounts)

`

sortie: Agrégation Par Clé somme des Résultats bar -> 3 foo -> 5

combineByKey:

3 paramètres en entrée

1. Valeur initiale : contrairement à aggregateByKey, n'a pas besoin de passer constante toujours, nous pouvons passer d'une fonction une fonction qui renvoie une nouvelle valeur.
2. la fonction de fusion
3. combiner la fonction

Exemple:`

val result = rdd.combineByKey(
                        (v) => (v,1),
                        ( (acc:(Int,Int),v) => acc._1 +v , acc._2 +1 ) ,
                        ( acc1:(Int,Int),acc2:(Int,Int) => (acc1._1+acc2._1) , (acc1._2+acc2._2)) 
                        ).map( { case (k,v) => (k,v._1/v._2.toDouble) })
        result.collect.foreach(println)

`

reduceByKey,aggregateByKey,combineByKey préféré sur groupByKey

Référence: Éviter groupByKey

Answer 2

• groupByKey() , c'est juste pour le groupe de votre jeu de données basé sur une touche. Il en résulte des données de brassage quand CA n'est pas déjà partitionné.
• reduceByKey() est quelque chose comme le fait de regrouper + agrégation. Nous pouvons dire reduceBykey() equvelent de dataset.groupe(...).réduire(...). Il va battre le moins de données contrairement aux groupByKey().
• aggregateByKey() est logiquement de même que reduceByKey() mais il permet de retourner le résultat dans d'autre type. En d'autres termes, il vous permet d'avoir une entrée de type x et de résultat cumulé en tant que type y. Par exemple, (1,2),(1,4) en entrée, et (1,"six") en sortie. Il prend également la valeur zéro qui sera appliqué au début de chaque touche.

Remarque : l'Un des points communs est qu'ils sont à l'échelle de l'exploitation.

Answer 3

Alors que les deux reducebykey et groupbykey va produire la même réponse, la reduceByKey exemple fonctionne beaucoup mieux sur un grand ensemble de données. C'est parce que l'Étincelle sait qu'il peut combiner de sortie avec une clé commune sur chaque partition avant de brouiller les données.

D'autre part, lors de l'appel de groupByKey - toutes les paires clé-valeur sont bousculés. C'est beaucoup de unnessary de données pour être transféré sur le réseau.

pour de plus amples vérifier ce lien ci-dessous

https://databricks.gitbooks.io/databricks-spark-knowledge-base/content/best_practices/prefer_reducebykey_over_groupbykey.html

Answer 4

Bien que les deux d'entre eux vont chercher les mêmes résultats, il y a une différence significative dans la performance de ces deux fonctions. reduceByKey() fonctionne mieux avec les plus grands ensembles de données lorsque comparé à d' groupByKey().

En reduceByKey(), paires sur la même machine avec la même clé sont combinés (à l'aide de la fonction passée en reduceByKey()) avant que les données soient bien mélangés. Alors la fonction est appelée de nouveau à réduire toutes les valeurs de chaque partition pour produire un résultat final.

En groupByKey(), toutes les paires clé-valeur sont bousculés. C'est beaucoup de données inutiles pour être transféré sur le réseau.

Answer 5

ReduceByKey reduceByKey(func, [numTasks])-

Les données sont combinés de sorte qu'à chaque partition il doit y avoir au moins une valeur pour chaque clé. Et puis shuffle arrive et il est envoyé sur le réseau à certains exécuteur testamentaire d'un peu d'action, tels que réduire.

GroupByKey - groupByKey([numTasks])

Il n'est pas de fusionner les valeurs de la clé, mais directement le shuffle processus qui se passe et ici beaucoup de données est envoyé à chaque partition, presque la même que les données initiales.

Et la fusion de valeurs pour chaque clé est fait après la lecture aléatoire. Ici beaucoup de données stockées sur final travailleur nœud afin résultant d'un problème de mémoire.

AggregateByKey - aggregateByKey(zeroValue)(seqOp, combOp, [numTasks]) Il est semblable à reduceByKey mais vous pouvez fournir des valeurs initiales lors de l'exécution de l'agrégation.

L'utilisation d' reduceByKey

• reduceByKey peut être utilisé lorsque nous courons sur grand ensemble de données.

• reduceByKey lorsque l'entrée et la sortie des types de valeur sont de même type plus de aggregateByKey

En outre, il a recommandé de ne pas utiliser groupByKey et préfèrent reduceByKey. Pour plus de détails vous pouvez consulter ici.

Vous pouvez aussi vous référer à cette question pour comprendre plus en détail comment reduceByKey et aggregateByKey.