Spark perbedaan antara reduceByKey vs groupByKey vs aggregateByKey vs combineByKey

groupByKey:

Sintaks:

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

groupByKey dapat menyebabkan keluar dari masalah disk sebagai data yang dikirim melalui jaringan dan dikumpulkan pada mengurangi pekerja.

reduceByKey:

Sintaks:

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

Data gabungan di masing-masing partisi, hanya satu keluaran untuk salah satu kunci di masing-masing partisi untuk mengirim melalui jaringan. reduceByKey diminta menggabungkan semua nilai-nilai ke nilai lain dengan tepat jenis yang sama.

aggregateByKey:

sama seperti reduceByKey, yang mengambil nilai awal.

3 parameter sebagai input aku. nilai awal ii. Combiner logika iii. urutan logika op

Contoh:

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)

ouput: Agregat Dengan Kunci Hasil sum bar -> 3 foo -> 5

combineByKey:

3 parameter sebagai input

1. Nilai awal: tidak seperti aggregateByKey, tidak perlu melewati selalu konstan, kita dapat melewati sebuah fungsi yang akan mengembalikan nilai baru.
2. penggabungan fungsi
3. menggabungkan fungsi

Contoh:

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 lebih disukai groupByKey

Referensi: Hindari groupByKey

Sementara kedua reducebykey dan groupbykey akan menghasilkan jawaban yang sama, reduceByKey contoh bekerja jauh lebih baik pada dataset besar. Yang's karena Percikan tahu hal ini dapat menggabungkan output dengan kunci yang sama pada setiap partisi sebelum pengacakan data.

Di sisi lain, ketika memanggil groupByKey - semua pasangan kunci-nilai dikocok sekitar. Ini adalah banyak maupun sebaliknya data menjadi ditransfer melalui jaringan.

untuk lebih detail check this link di bawah ini

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

• groupByKey() adalah untuk mengelompokkan data berdasarkan kunci. Hal ini akan mengakibatkan data yang menyeret ketika DRD belum dipartisi.
• reduceByKey() adalah sesuatu seperti pengelompokan + agregasi. Kita dapat mengatakan reduceBykey() equvelent untuk dataset.kelompok(...).mengurangi(...). Itu akan mengacak data yang kurang tidak seperti groupByKey().
• aggregateByKey() adalah logis yang sama seperti reduceByKey() tetapi memungkinkan anda kembali hasilnya dalam berbagai jenis. Dengan kata lain, ini memungkinkan anda memiliki masukan sebagai tipe x dan agregat hasil sebagai jenis y. Misalnya (1,2),(1,4) sebagai input dan (1,"enam") sebagai output. Hal ini juga membutuhkan nol-nilai yang akan diterapkan pada awal masing-masing kunci.

Catatan : Satu kesamaan mereka semua berbagai operasi.

Meskipun keduanya akan mengambil hasil yang sama, ada perbedaan yang signifikan dalam kinerja dari kedua fungsi. reduceByKey() bekerja lebih baik dengan dataset yang lebih besar bila dibandingkan dengan groupByKey().

Di reduceByKey(), pasang pada mesin yang sama dengan kunci yang sama digabungkan (dengan menggunakan fungsi disahkan menjadi reduceByKey()) sebelum data dikocok. Kemudian fungsi ini dipanggil lagi untuk mengurangi semua nilai dari masing-masing partisi untuk menghasilkan suatu hasil akhir.

Di groupByKey(), semua pasangan kunci-nilai dikocok sekitar. Ini adalah banyak data yang tidak perlu untuk ditransfer melalui jaringan.

ReduceByKey reduceByKey(func, [numTasks])-

Data ini dikombinasikan sehingga pada setiap partisi harus ada setidaknya satu nilai untuk masing-masing kunci. Dan kemudian mengocok terjadi dan dikirimkan melalui jaringan ke beberapa khusus pelaksana untuk beberapa tindakan seperti mengurangi.

GroupByKey - groupByKey([numTasks])

Itu doesn't menggabungkan nilai-nilai untuk kunci tapi langsung mengocok proses yang terjadi dan di sini banyak data yang akan dikirim ke masing-masing partisi, hampir sama dengan data awal.

Dan penggabungan dari nilai-nilai untuk masing-masing tombol ini dilakukan setelah shuffle. Di sini banyak data yang tersimpan pada akhir worker node sehingga mengakibatkan keluar dari masalah memori.

AggregateByKey - aggregateByKey(zeroValue)(seqOp, combOp, [numTasks]) Hal ini mirip dengan reduceByKey tapi anda dapat memberikan nilai awal saat melakukan agregasi.

Penggunaan reduceByKey

• reduceByKey dapat digunakan ketika kita berjalan di besar set data.

• reduceByKey ketika input dan nilai output jenis ini adalah dari jenis yang sama atas aggregateByKey

Selain itu dianjurkan untuk tidak menggunakan groupByKey dan memilih reduceByKey. Untuk jelasnya anda bisa lihat di sini.

Anda juga dapat merujuk ini pertanyaan untuk memahami lebih detail bagaimana reduceByKey dan aggregateByKey.

Kemudian terlepas dari hal-4, kami memiliki

foldByKey yang sama seperti reduceByKey tapi dengan pengguna yang ditetapkan Nilai Nol.

AggregateByKey membutuhkan 3 parameter sebagai input dan menggunakan 2 fungsi untuk penggabungan(satu untuk penggabungan pada partisi yang sama dan yang lain untuk menggabungkan nilai-nilai di partisi. Parameter pertama adalah ZeroValue)

sedangkan

ReduceBykey mengambil 1 parameter saja yang merupakan fungsi untuk penggabungan.

CombineByKey membutuhkan 3 parameter dan semua 3 fungsi. Mirip dengan aggregateBykey kecuali dapat memiliki fungsi ZeroValue.

GroupByKey tidak mengambil parameter dan memiliki segalanya. Juga, itu adalah sebuah overhead untuk transfer data di partisi.