Dask示例,其中与线程调度程序相比,具有进程的调度程序需要过多的内存
你好,
我遇到了一个dask.array示例,其中线程(共享内存)调度程序(dask.get,dask.threaded.get)和带有工作进程的调度程序(dask.multiprocessing.get,distributed.Client().get)之间的计算时间和所需内存存在很大差异
我已经在带有SSD的2013 Core i7 16GB macOS Macbook Pro上测试了此设置。
当前的仿真在长度为ndims的许多dimlen向量之间实现了网格操作,然后对它们执行一些简单的元素运算,然后通过对各个维度求和得出最终结果。如果没有dask,示例将是这样的:网格数组的副本将与8*(dimlen**ndims)/1024**3 = 7.4 GByte一样大。因为我们有ndim = 3参数,所以如果所有操作都是由网格参数的普通副本完成的,则我们将需要超过16 GB的RAM。 (顺便说一句:如果通过numpy来访问示例,则无论如何numpy.broadcast_to和numpy.transpose不会创建完整副本。只有在创建res期间,才会分配完整的7.4 GByte数组。)
到目前为止,我了解到,多处理和分布式调度程序中的速度下降是由于大量的RAM消耗和某些任务而导致的,这些任务会写入磁盘(在分布式诊断网页上看到)。但是我无法解释这种行为,因为我目前对要计算的dask-graph的理解是:
使用dask的想法是通过使用dask.array进行分块来减少内存需求。假设为8*(chunklen**ndims)/1024**2 = 7.6 MByte,一个网格状参数块的最大副本数为float64。同样,在约简操作(一次一维)中,必须将大块块连接时,我们应该只以8*(dimlen/chunklen)*(chunklen**ndims)/1024**2 = 76 MByte的最大大块块结束。假设我们有4个进程,那么在任何给定时间,我们仍然只需要上述块大小的四倍即可。但是,资源监视显示这些调度程序涉及各种进程的16GB RAM的总消耗量。
我将对我在这里错过的确切内容进行更深入的解释,这将不胜感激。
预先感谢,马库斯
import numpy as np
import dask.array as da
from dask import get as single_threaded_get
from dask.threaded import get as threaded_get
from dask.multiprocessing import get as multiprocessing_get
ndims = 3
dimlen = 1000
chunklen = 100
# Some input data, which usually would come elsewhere
xs = [np.random.randn(dimlen) for _ in range(ndims)]
# Cast them to dask.array
ys = [da.from_array(x, chunks=chunklen) for x in xs]
# Meshgrid
zs = [da.broadcast_to(y, ndims*(dimlen,)) for y in ys]
zs = [da.rechunk(z, chunks=ndims*(chunklen,)) for z in zs]
_a = tuple(range(ndims))
zs = [da.transpose(z, axes=_a[i:] + _a[:i]) for i, z in enumerate(zs)]
# Some simple element-wise processing of n dimensional arguments
res = zs[0]
for z in zs[1:]:
res = res + z
# Some reduction of all dimensions to a scalar
for i in range(ndims):
res = da.sum(res, axis=-1)
res
dask.array<sum-aggregate, shape=(), dtype=float64, chunksize=()>
len(list(res.dask.keys()))
#12617
%%timeit -n 1 -r 1
x = res.compute(get=single_threaded_get)
#10.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -n 1 -r 1
x = res.compute(get=threaded_get)
#7.32 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -n 1 -r 1
x = res.compute(get=multiprocessing_get)
#5h 14min 52s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
from distributed import Client
client = Client()
%%timeit -n 1 -r 1
x = res.compute(get=client.get)
#7min 37s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
设定环境
用创建的Conda环境
$conda create -n py35 python=3.5 dask distributed jupyter
$source activate py35
$jupyter notebook .
!conda list -e
# This file may be used to create an environment using:
# $ conda create --name <env> --file <this file>
# platform: osx-64
appnope=0.1.0=py35_0
bleach=1.5.0=py35_0
bokeh=0.12.5=py35_1
chest=0.2.3=py35_0
click=6.7=py35_0
cloudpickle=0.2.2=py35_0
dask=0.14.3=py35_0
decorator=4.0.11=py35_0
distributed=1.16.3=py35_0
entrypoints=0.2.2=py35_1
heapdict=1.0.0=py35_1
html5lib=0.999=py35_0
icu=54.1=0
ipykernel=4.6.1=py35_0
ipython=6.0.0=py35_1
ipython_genutils=0.2.0=py35_0
ipywidgets=6.0.0=py35_0
jedi=0.10.2=py35_2
jinja2=2.9.6=py35_0
jsonschema=2.6.0=py35_0
jupyter=1.0.0=py35_3
jupyter_client=5.0.1=py35_0
jupyter_console=5.1.0=py35_0
jupyter_core=4.3.0=py35_0
locket=0.2.0=py35_1
markupsafe=0.23=py35_2
mistune=0.7.4=py35_0
mkl=2017.0.1=0
msgpack-python=0.4.8=py35_0
nbconvert=5.1.1=py35_0
nbformat=4.3.0=py35_0
notebook=5.0.0=py35_0
numpy=1.12.1=py35_0
openssl=1.0.2k=2
pandas=0.20.1=np112py35_0
pandocfilters=1.4.1=py35_0
partd=0.3.8=py35_0
path.py=10.3.1=py35_0
pexpect=4.2.1=py35_0
pickleshare=0.7.4=py35_0
pip=9.0.1=py35_1
prompt_toolkit=1.0.14=py35_0
psutil=5.2.2=py35_0
ptyprocess=0.5.1=py35_0
pygments=2.2.0=py35_0
pyqt=5.6.0=py35_2
python=3.5.3=1
python-dateutil=2.6.0=py35_0
pytz=2017.2=py35_0
pyyaml=3.12=py35_0
pyzmq=16.0.2=py35_0
qt=5.6.2=2
qtconsole=4.3.0=py35_0
readline=6.2=2
requests=2.14.2=py35_0
setuptools=27.2.0=py35_0
simplegeneric=0.8.1=py35_1
sip=4.18=py35_0
six=1.10.0=py35_0
sortedcollections=0.5.3=py35_0
sortedcontainers=1.5.7=py35_0
sqlite=3.13.0=0
tblib=1.3.2=py35_0
terminado=0.6=py35_0
testpath=0.3=py35_0
tk=8.5.18=0
toolz=0.8.2=py35_0
tornado=4.5.1=py35_0
traitlets=4.3.2=py35_0
wcwidth=0.1.7=py35_0
wheel=0.29.0=py35_0
widgetsnbextension=2.0.0=py35_0
xz=5.2.2=1
yaml=0.1.6=0
zict=0.1.2=py35_0
zlib=1.2.8=3
@ kakk11建议的进一步跟进
你好@ kakk11,
非常感谢您的回答和努力。我对此进行了进一步的研究,如果将您的示例增加到我的问题的大小,即
ndims = 3,
dimlen = 1000,
chunklen = 100,我将得到以下行为,对于“慢速解决方案”,多处理调度程序又需要更长的时间。但是请记住,由于实际应用,我需要慢速解决方案的结构。
%%timeit -r 1 -n 1
fast_solution(x).compute(get=single_threaded_get)
# 2min 4s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -r 1 -n 1
fast_solution(x).compute(get=threaded_get)
# 49.5 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -r 1 -n 1
fast_solution(x).compute(get=multiprocessing_get)
# 55.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -r 1 -n 1
slow_solution(x).compute(get=single_threaded_get)
# 2min 21s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -r 1 -n 1
slow_solution(x).compute(get=threaded_get)
# 56.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
%%timeit -r 1 -n 1
slow_solution(x).compute(get=multiprocessing_get)
# 10min 31s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
您也可以尝试以下代码来查看两个版本的dask图之间的差异。
fast_solution直到最后都只包含并行路径,而
slow_solution具有更金字塔的结构。但是考虑到我对传递的单个块大小的考虑,我不明白问题出在哪里。
ndims = 2
dimlen = 1000
chunklen = 500
# ...
from dask.dot import dot_graph
dot_graph(fast_solution(x).dask)
dot_graph(slow_solution(x).dask)
@mrocklin请求进一步跟进,以简化示例
您好@MRocklin,
感谢您的回答。我了解到,有些计算图具有很高的数据交换成本,并且手头的示例属于此类。我进一步简化了它,导致了二维的网格等效操作,然后将尺寸全部缩减为标量。也许这可以作为示例,让您对问题有更多的了解
distributed行为正常,并且该示例具有较高的数据交换成本distributed调度程序的问题。 请注意,该示例仅应用于分析内存使用情况,而不是CPU性能。由于这是一个简化的示例,因此不会为CPU产生足够的工作负载。
我想强调的是,我之所以要关注此问题,是因为我有一个愿景,即dask/distributed应该能够处理图结构,其总数组大小的中间值远远超过 worker 的累积RAM,前提是块大小并且本 map 结构远低于工作人员RAM的容量。该示例实现了这样的图形结构。
因此,这是更新的jupyter笔记本: dask_distributed_RAM_usage_meshgrid_operation.ipynb.zip
期待有关该主题的更多讨论,并感谢您为此付出的努力。
马库斯
请您参考如下方法:
感谢您进行有趣的测试。好像multiprocessing_get的总和超过列表有问题,我只能猜测为什么。默认情况下,dask.Bag中使用多处理,这是python对象而不是数组的用例,并且在需要进行进程间通信时不能快速执行。
无论如何,当您在计算的所有步骤中使用dask函数时,它实际上在所有情况下都能快速运行,请参见我的示例
import dask.array as da
from dask.multiprocessing import get as multiprocessing_get
import time
t0 = time.time()
ndims = 3
dimlen = 400
chunklen = 100
x = [da.random.normal(10, 0.1, size=ndims*(dimlen,), chunks=ndims*(chunklen,)) for k in range(ndims)]
def slow_solution(x):
res = x[0]
for z in x[1:]:
res = res + z
return da.sum(res)
def fast_solution(x):
return da.sum(da.stack(x))
t1 = time.time()
print("start fast f-n")
fast_solution(x).compute(get=multiprocessing_get)
t2 = time.time()
print("start slow f-n")
slow_solution(x).compute(get=multiprocessing_get)
t3 = time.time()
print("Whole script: ", t3 - t0)
print("fast function: ", t2 - t1)
print("slow function: ", t3 - t2)
更新
是否有特定的原因为什么您需要使用
multiprocessing_get而
threaded对您不起作用,或者您只是好奇? dask的文档并不十分全面,但是据我了解,
multiprocessing解决方案通常用于dask Bag,它是任何种类的python对象的更通用解决方案。而且它的性能存在已知限制,请参见
http://dask.pydata.org/en/latest/shared.html#known-limitations
