web-dev-qa-db-ja.com

大きなブロードキャスト変数を適切に使用するためのヒント？

サイズが約100MBのブロードキャスト変数を使用しています。これは、次のように概算しています。

>>> data = list(range(int(10*1e6)))
>>> import cPickle as pickle
>>> len(pickle.dumps(data))
98888896

3つのc3.2xlargeエグゼキューターとm3.largeドライバーを備えたクラスターで実行し、次のコマンドで対話型セッションを起動します。

IPYTHON=1 pyspark --executor-memory 10G --driver-memory 5G --conf spark.driver.maxResultSize=5g

RDDで、このブロードキャスト変数への参照を保持すると、メモリ使用量が爆発的に増加します。 100 MBの変数への100の参照の場合、100回コピーされたとしても、データ使用量は合計で10 GB以下になると予想されます（3ノードで30 GBは言うまでもありません）。ただし、次のテストを実行すると、メモリ不足エラーが発生します。

data = list(range(int(10*1e6)))
metadata = sc.broadcast(data)
ids = sc.parallelize(Zip(range(100), range(100)))
joined_rdd = ids.mapValues(lambda _: metadata.value)
joined_rdd.persist()
print('count: {}'.format(joined_rdd.count()))

スタックトレース：

TaskSetManager: Lost task 17.3 in stage 0.0 (TID 75, 10.22.10.13): 

org.Apache.spark.api.python.PythonException: Traceback (most recent call last):
  File "/usr/lib/spark/python/lib/pyspark.Zip/pyspark/worker.py", line 111, in main
    process()
  File "/usr/lib/spark/python/lib/pyspark.Zip/pyspark/worker.py", line 106, in process
    serializer.dump_stream(func(split_index, iterator), outfile)
  File "/usr/lib/spark/python/pyspark/rdd.py", line 2355, in pipeline_func
    return func(split, prev_func(split, iterator))
  File "/usr/lib/spark/python/pyspark/rdd.py", line 2355, in pipeline_func
    return func(split, prev_func(split, iterator))
  File "/usr/lib/spark/python/pyspark/rdd.py", line 317, in func
    return f(iterator)
  File "/usr/lib/spark/python/pyspark/rdd.py", line 1006, in <lambda>
    return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
  File "/usr/lib/spark/python/pyspark/rdd.py", line 1006, in <genexpr>
    return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
  File "/usr/lib/spark/python/lib/pyspark.Zip/pyspark/serializers.py", line 139, in load_stream
    yield self._read_with_length(stream)
  File "/usr/lib/spark/python/lib/pyspark.Zip/pyspark/serializers.py", line 164, in _read_with_length
    return self.loads(obj)
  File "/usr/lib/spark/python/lib/pyspark.Zip/pyspark/serializers.py", line 422, in loads
    return pickle.loads(obj)
MemoryError


  at org.Apache.spark.api.python.PythonRDD$$anon$1.read(PythonRDD.scala:138)
  at org.Apache.spark.api.python.PythonRDD$$anon$1.<init>(PythonRDD.scala:179)
  at org.Apache.spark.api.python.PythonRDD.compute(PythonRDD.scala:97)
  at org.Apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:297)
  at org.Apache.spark.rdd.RDD.iterator(RDD.scala:264)
  at org.Apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:66)
  at org.Apache.spark.scheduler.Task.run(Task.scala:88)
  at org.Apache.spark.executor.Executor$TaskRunner.run(Executor.scala:214)
  at Java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.Java:1145)
  at org.Apache.spark.scheduler.Task.run(Task.scala:88)
  at org.Apache.spark.executor.Executor$TaskRunner.run(Executor.scala:214)
  at Java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.Java:1145)
  at Java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.Java:615)
  at Java.lang.Thread.run(Thread.Java:745)

16/05/25 23:57:15 ERROR TaskSetManager: Task 17 in stage 0.0 failed 4 times; aborting job
---------------------------------------------------------------------------
Py4JJavaError                             Traceback (most recent call last)
<ipython-input-1-7a262fdfa561> in <module>()
      7 joined_rdd.persist()
      8 print('persist called')
----> 9 print('count: {}'.format(joined_rdd.count()))

/usr/lib/spark/python/pyspark/rdd.py in count(self)
   1004         3
   1005         """
-> 1006         return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
   1007
   1008     def stats(self):

/usr/lib/spark/python/pyspark/rdd.py in sum(self)
    995         6.0
    996         """
--> 997         return self.mapPartitions(lambda x: [sum(x)]).fold(0, operator.add)
    998
    999     def count(self):

/usr/lib/spark/python/pyspark/rdd.py in fold(self, zeroValue, op)
    869         # zeroValue provided to each partition is unique from the one provided
    870         # to the final reduce call
--> 871         vals = self.mapPartitions(func).collect()
    872         return reduce(op, vals, zeroValue)
    873

/usr/lib/spark/python/pyspark/rdd.py in collect(self)
    771         """
    772         with SCCallSiteSync(self.context) as css:
--> 773             port = self.ctx._jvm.PythonRDD.collectAndServe(self._jrdd.rdd())
    774         return list(_load_from_socket(port, self._jrdd_deserializer))
    775

/usr/lib/spark/python/lib/py4j-0.8.2.1-src.Zip/py4j/Java_gateway.py in __call__(self, *args)

  at py4j.reflection.MethodInvoker.invoke(MethodInvoker.Java:231)
  at py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.Java:379)
  at py4j.Gateway.invoke(Gateway.Java:259)
  at py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.Java:133)
  at py4j.commands.CallCommand.execute(CallCommand.Java:79)
  at py4j.GatewayConnection.run(GatewayConnection.Java:207)
  at Java.lang.Thread.run(Thread.Java:745)

ピクルスの逆シリアル化のメモリ使用量が問題になることについての以前のスレッドを見てきました。ただし、ブロードキャスト変数は1回だけ逆シリアル化（およびエグゼキュータのメモリにロード）され、その後の.valueへの参照はそのメモリ内アドレスを参照すると予想されます。しかし、そうではないようです。私は何かが足りないのですか？

ブロードキャスト変数で見た例では、それらを辞書として使用し、データセットを変換するために1回使用しました（つまり、空港の頭字語を空港名に置き換えます）。ここでそれらを永続化する背後にある動機は、ブロードキャスト変数とその相互作用の方法を知っているオブジェクトを作成し、それらのオブジェクトを永続化し、それらを使用して複数の計算を実行することです（sparkメモリ内）。

大きな（100 MB +）ブロードキャスト変数を使用するためのヒントは何ですか？ブロードキャスト変数の永続化は誤った方向に進んでいますか？これはおそらくPySparkに固有の問題ですか？

ありがとうございました！あなたの助けに感謝します。

この質問は databricksフォーラム にも投稿しています。

編集-フォローアップの質問：

デフォルトのSparkシリアライザーのバッチサイズは65337であることが提案されました。異なるバッチでシリアル化されたオブジェクトは同じものとして識別されず、異なるメモリアドレスが割り当てられます。ここでは、組み込みのid function。ただし、理論的にはシリアル化に256バッチかかる大きなブロードキャスト変数を使用しても、2つの異なるコピーしか表示されません。もっと多く表示されるべきではありませんか？バッチシリアル化がどのように機能するかについての私の理解は正しくありませんか？

>>> sc.serializer.bestSize
65536
>>> import cPickle as pickle
>>> broadcast_data = {k: v for (k, v) in enumerate(range(int(1e6)))}
>>> len(pickle.dumps(broadcast_data))
16777786
>>> len(pickle.dumps({k: v for (k, v) in enumerate(range(int(1e6)))})) / sc.serializer.bestSize
256
>>> bd = sc.broadcast(broadcast_data)
>>> rdd = sc.parallelize(range(100), 1).map(lambda _: bd.value)
>>> rdd.map(id).distinct().count()
1
>>> rdd.cache().count()
100
>>> rdd.map(id).distinct().count()
2
pythonapache-sparkpysparkpicklerdd
9
captaincapsaicin

さて、悪魔は細部にあります。これが発生する理由を理解するには、PySparkシリアライザーを詳しく調べる必要があります。まず、デフォルト設定でSparkContextを作成しましょう。

from pyspark import SparkContext

sc = SparkContext("local", "foo")

デフォルトのシリアライザーを確認します。

sc.serializer
## AutoBatchedSerializer(PickleSerializer())

sc.serializer.bestSize
## 65536

それは私たちに3つの異なることを教えてくれます：

  • これはAutoBatchedSerializerシリアライザーです
  • PickleSerializerを使用して実際のジョブを実行しています
  • シリアル化されたバッチのbestSizeは65536バイトです

一目で ソースコードで このシリアル化は、実行時にシリアル化されるレコードの数を調整し、バッチサイズを10 * bestSize未満に維持しようとすることを示します。重要な点は、単一のパーティション内のすべてのレコードが同時にシリアル化されるわけではないということです。

次のように実験的に確認できます。

from operator import add

bd = sc.broadcast({})

rdd = sc.parallelize(range(10), 1).map(lambda _: bd.value)
rdd.map(id).distinct().count()
## 1

rdd.cache().count()
## 10

rdd.map(id).distinct().count()
## 2

シリアル化-逆シリアル化後のこの単純な例でもわかるように、2つの異なるオブジェクトを取得します。 pickleで直接動作する同様の動作を観察できます。

v = {}
vs = [v, v, v, v]

v1, *_, v4 = pickle.loads(pickle.dumps(vs))
v1 is v4
## True

(v1_, v2_), (v3_, v4_) = (
    pickle.loads(pickle.dumps(vs[:2])),
    pickle.loads(pickle.dumps(vs[2:]))
)

v1_ is v4_
## False

v3_ is v4_
## True

選択を解除した後、同じオブジェクトを同じバッチ参照でシリアル化された値。異なるバッチからの値は、異なるオブジェクトを指します。

実際にはSpark複数のシリアル化と異なるシリアル化戦略。たとえば、無限サイズのバッチを使用できます。

from pyspark.serializers import BatchedSerializer, PickleSerializer

rdd_ = (sc.parallelize(range(10), 1).map(lambda _: bd.value)
    ._reserialize(BatchedSerializer(PickleSerializer())))
rdd_.cache().count()

rdd_.map(id).distinct().count()
## 1

serializerおよび/またはbatchSizeパラメーターをSparkContextコンストラクターに渡すことにより、シリアライザーを変更できます。

sc = SparkContext(
    "local", "bar",
    serializer=PickleSerializer(),  # Default serializer
    # Unlimited batch size -> BatchedSerializer instead of AutoBatchedSerializer
    batchSize=-1  
)

sc.serializer
## BatchedSerializer(PickleSerializer(), -1)

さまざまなシリアライザーとバッチ処理戦略を選択すると、さまざまなトレードオフ（速度、任意のオブジェクトをシリアル化する機能、メモリ要件など）が発生します。

Sparkのブロードキャスト変数はエグゼキュータースレッド間で共有されないため、同じワーカー上に複数の逆シリアル化されたコピーが同時に存在する可能性があることも覚えておく必要があります。

さらに、シャッフルが必要な変換を実行すると、これと同様の動作が見られます。

10
zero323