Diferencia de chispa entre reduceByKey vs groupByKey vs aggregateByKey vs combineByKey

Solución:

groupByKey:

Sintaxis:

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

groupByKey puede causar problemas fuera del disco ya que los datos se envían a través de la red y se recopilan en los trabajadores reducidos.

reduceByKey:

Sintaxis:

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

Los datos se combinan en cada partición, solo una salida para una clave en cada partición para enviar a través de la red. reduceByKey requería combinar todos sus valores en otro valor con el mismo tipo exacto.

aggregateByKey:

igual que reduceByKey, que toma un valor inicial.

3 parámetros como entrada i. valor inicial ii. Lógica del combinador iii. lógica de secuencia de operaciones

Ejemplo:

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)

salida:
Agregado por barra de resultados de suma clave -> 3 foo -> 5

combineByKey:

3 parámetros como entrada

1. Valor inicial: a diferencia de aggregateByKey, no es necesario pasar constante siempre, podemos pasar una función que devolverá un nuevo valor.
2. función de fusión
3. combinar función

Ejemplo:

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 preferido sobre groupByKey

Referencia:
Evite groupByKey

• groupByKey() es solo agrupar su conjunto de datos en función de una clave. Dará como resultado la mezcla de datos cuando RDD aún no está particionado.
• reduceByKey() es algo así como agrupación + agregación. Podemos decir reduceBykey () equivalente a dataset.group (…). Reduce (…). Mezclará menos datos a diferencia de groupByKey().
• aggregateByKey() es lógicamente igual que reduceByKey () pero le permite devolver el resultado en un tipo diferente. En otras palabras, le permite tener una entrada como tipo x y un resultado agregado como tipo y. Por ejemplo (1,2), (1,4) como entrada y (1, “seis”) como salida. También se necesita valor cero que se aplicará al principio de cada tecla.

Nota : Una similitud es que todas son operaciones amplias.

Si bien tanto reducebykey como groupbykey producirán la misma respuesta, el ejemplo reduceByKey funciona mucho mejor en un conjunto de datos grande. Eso es porque Spark sabe que puede combinar la salida con una clave común en cada partición antes de barajar los datos.

Por otro lado, al llamar a groupByKey, todos los pares clave-valor se mezclan. Se trata de una gran cantidad de datos innecesarios para ser transferidos a través de la red.

para más detalles, consulte este enlace a continuación

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

---

---

Utiliza Nuestro Buscador