Spark'de neden iki farklı API toplanıyor ve katlanıyor?

Question

Scala standart lib kullanarak, böyle Somthing yapabilirsiniz:

scala> val scalaList = List(1,2,3) 
scalaList: List[Int] = List(1, 2, 3) 

scala> scalaList.foldLeft(0)((acc,n)=>acc+n) 
res0: Int = 6 

birçok Ints dışında bir Int yapma.

Ve böyle bir şey yapabilirsiniz:

scala> scalaList.foldLeft("")((acc,n)=>acc+n.toString) 
res1: String = 123 

birçok Ints dışında bir dize yapma.

Yani, foldLeft ister homojen ister heterojen olabilir, hangisini istiyorsak, bir API içinde. olabilir

scala> val rdd = sc.parallelize(List(1,2,3)) 
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:12 
scala> rdd.fold(0)((acc,n)=>acc+n) 
res1: Int = 6 

kat API foldLeft benzer, ancak, bir RDD [Uluslararası] sadece homojen geçerli:

Spark iken birçok Ints dışında bir Int istiyorsanız, bunu yapabilirim sadece katlama ile Int üretir. Bir RDD [Int] artık bir dize üretebilir

scala> rdd.aggregate("")((acc,n)=>acc+n.toString, (s1,s2)=>s1+s2) 
res11: String = 132 

Bu heterojen olduğunu:

çok kıvılcım bir agrega API vardır.

Peki, neden kıvılcım ve toplam Spark'deki iki farklı API olarak uygulanmaktadır?

Neden hem homojen hem de heterojen olabilen foldLeft gibi tasarlanmadılar?

(bu saçma bir soru olup olmadığını Spark için çok yeni, affedersiniz lütfen.) O değerlendirmenin sabit sırasına bağlı değildir, çünkü

Answer 1

fold daha verimli uygulanabilir. Bu nedenle, her küme düğümü, kendi başına fold kendi öbeklerini ve sonunda bir küçük genel fold olabilir. Oysa, foldLeft ile her elemanın sıraya göre katlanması ve paralel olarak hiçbir şey yapılamaz.

(Ayrıca kolaylık için ortak durum için daha basit bir API olması güzel. Standart lib bu nedenle reduce yanı sıra foldLeft vardır)

Answer 2

Özellikle Spark, hesaplama dağıtılır ve paralel olarak yapılması, Yani foldLeft standart kütüphanede olduğu gibi uygulanamaz.

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U 

Answer 3

Bunun yerine, toplam iki işlev, nihai değer her bir bölümden U birleştiren tip U bir değerinin oluşturulması, tip T her bir elemanı ile ilgili fold benzer bir işlemi gerçekleştiren bir ve diğer gerektirir

foldLeft, foldRight, reduceLeft, reduceRight, scanLeft ve scanRight, biriken parametrenin giriş parametrelerinden farklı olabildiği ((A, B) -> B) işlemlerdir ve bu işlemler yalnızca sıralı olarak gerçekleştirilebilir.

fold, biriken parametrenin giriş parametreleriyle aynı olması gereken bir işlemdir ((A, A) -> A). Daha sonra paralel olarak yürütülebilir.

aggregation, biriken parametrenin giriş parametreleriyle farklı türde olabileceği bir işlemdir, ancak sonra toplanan parametrelerin nihai sonuçta nasıl birleştirilebileceğini tanımlayan ek bir işlev sağlamanız gerekir. Bu işlem paralel yürütmeye izin verir. aggregation işlemi, foldLeft ve fold'un birleşimidir.

daha detaylı bilgi için ders "Paralel programlama" için Coursera videolarına bakabilirsiniz:

• https://www.coursera.org/learn/parprog1/lecture/efzVT/data-parallel-operations-i
• https://www.coursera.org/learn/parprog1/lecture/shwKn/data-parallel-operations-ii