Funke reduzieren Funktion: verstehen, wie es funktioniert

Question

Ich nehme diese course.

Es besagt, dass der Reduce-Vorgang auf RDD eine Maschine zu einer Zeit durchgeführt wird. Das heißt, wenn Ihre Daten auf zwei Computer aufgeteilt sind, dann funktioniert die unten stehende Funktion für Daten im ersten Computer, findet das Ergebnis für diese Daten und dann wird ein einzelner Wert vom zweiten Computer genommen, die Funktion ausgeführt und es wird fortgesetzt auf diese Weise, bis es mit allen Werten von Maschine 2 fertig ist. Ist das korrekt?

Ich dachte, dass die Funktion zur gleichen Zeit auf beiden Maschinen in Betrieb nehmen wird und dann, wenn es Ergebnisse von zwei Maschinen hat, wird es wieder die Funktion zum letzten Mal

rdd1=rdd.reduce(lambda x,y: x+y) 

Update ausführen 1-- ------------------------------------------

wird unter den Schritten geben schnellere Antwort im Vergleich zu reduzieren Funktion?

Rdd=[3,5,4,7,4] 
seqOp = (lambda x, y: x+y) 
combOp = (lambda x, y: x+y) 
collData.aggregate(0, seqOp, combOp) 

Update 2 -----------------------------------

sollten beide Satz von Codes unten in der gleichen Zeit ausgeführt? Ich überprüfte und es scheint, dass beide die gleiche Zeit nehmen.

import datetime 

data=range(1,1000000000) 
distData = sc.parallelize(data,4) 
print(datetime.datetime.now()) 
a=distData.reduce(lambda x,y:x+y) 
print(a) 
print(datetime.datetime.now()) 

seqOp = (lambda x, y: x+y) 
combOp = (lambda x, y: x+y) 
print(datetime.datetime.now()) 
b=distData.aggregate(0, seqOp, combOp) 
print(b) 
print(datetime.datetime.now()) 

Answer 1

reduce Verhalten unterscheidet sich ein wenig zwischen nativem (Scala) und Gast Sprachen (Python), aber die Dinge ein wenig zu vereinfachen:

• jede Partition verarbeitet sequentiell Element für Element
• mehrere Partitionen können gleichzeitig von einem einzelnen Worker (mehreren Executor-Threads) oder verschiedenen Workern
• verarbeitet werden, werden Teilergebnisse zum Treiber abgerufen, wo die endgültige Reduktion angewendet wird (dies ist ein Teil mit di fferent Implementierung in PySpark und Scala)

Da es sieht aus wie Sie Python verwenden können auf den Code werfen Sie einen Blick:

1. reducecreates a simple wrapper für einen Benutzer bereitgestellte Funktion:

   def func(iterator): 
       ... 
   

2. Dies ist Wrapper is used to mapPartitions:

   vals = self.mapPartitions(func).collect() 
   

   Es sollte dieser Code ist beschämend parallel offensichtlich sein und kümmert sich nicht darum, wie die Ergebnisse

3. Gesammelte verwendet werden vals der Reihe nach auf den Fahrer reduziert werden unter Verwendung von Standard-Python reduce:

   reduce(f, vals) 
   

   wo f ist a Funktionen übergeben an RDD.reduce

Im Vergleich wird Scala mer Teilergebnisse asynchron wie sie von den Arbeitern stammen.

Im Falle treeReduce Schritt 3. kann auch verteilt durchgeführt werden. Siehe Understanding treeReduce() in Spark

reduce Um es zusammenzufassen, ohne Fahrerseite Verarbeitung verwendet genau die gleichen Mechanismen (mapPartitions) als die grundlegenden Transformationen wie map oder filter und bieten das gleiche Maß an Parallelität (erneut ohne Treibercode). Wenn Sie eine große Anzahl von Partitionen haben oder f teuer ist, können Sie die endgültige Verschmelzung parallelisieren/verteilen, indem Sie tree* Familie der Methoden verwenden.