Question

我很困惑client.persist()和client.compute()之间的区别似乎（在某些情况下）开始计算并且都返回异步对象，但不是在我的简单示例中：

在这个例子中

from dask.distributed import Client
from dask import delayed
client = Client()

def f(*args):
    return args

result = [delayed(f(x)) for x in range(1000)]

x1 = client.compute(result)
x2 = client.persist(result)

此处x1和x2不同，但在一个不太重要的计算中result也是Delayed个对象的列表，使用client.persist(result)开始计算就像client.compute(result)一样。

Answer 1

相关文档页面位于：http://distributed.readthedocs.io/en/latest/manage-computation.html#dask-collections-to-futures

正如您所说，Client.compute和Client.persist都会使用惰性Dask集合并启动它们在集群上运行。他们的回归不同。

Client.persist为每个dask集合返回一个副本，其中之前提交的懒惰计算在集群上运行。这些集合的任务图现在只指向当前运行的Future对象。

因此，如果你坚持使用100个分区的dask数据帧，你就会回来一个具有100个分区的dask数据帧，每个分区都指向当前正在群集上运行的未来。
Client.compute为每个集合返回一个Future。这个未来指的是在一个worker上收集的单个Python对象结果。这通常用于小结果。

因此，如果你计算一个包含100个分区的dask.dataframe，你会得到一个指向包含所有数据的单个Pandas数据帧的Future

更务实的是，我建议在结果很大时使用persist，并且需要在许多计算机之间传播，并在结果较小时使用计算机并且只需要在一台计算机上使用计算机。

在实践中，我很少使用Client.compute，而是选择使用persist进行中间分段，而dask.compute则使用df = dd.read_csv('...') df = df[df.name == 'alice'] df = client.persist(df) # compute up to here, keep results in memory >>> df.value.max().compute() 100 >>> df.value.min().compute() 0来提取最终结果。

<target name="init">
        <property
        name="scala-library.jar"
        value="${env.SCALA_HOME}/lib/scala-library.jar"
         />
        <path id="build.classpath">
            <pathelement location="${lib}/anorm_2.10-2.3.1.jar"/>
            <pathelement location="${lib}/bootstrap-3.2.0.jar"/>
            <pathelement location="${lib}/jbcrypt-0.3m.jar"/>
            <pathelement location="${lib}/play-1.2.7.jar"/>
            <pathelement location="${lib}/play-ws_2.10-2.3.1.jar"/>
            <pathelement location="${lib}/webjars-play_2.10-2.3.0.jar"/>

            <fileset dir="${env.PLAY_HOME}/framework">
                <include name="*.jar"/>
            </fileset>
            <fileset dir="${env.PLAY_HOME}/framework/lib">
                <include name="*.jar"/>
            </fileset>
            <fileset dir="lib">
                <include name="*.jar"/>
            </fileset>

            <pathelement location="${scala-library.jar}"   />
            <pathelement location="${env.PLAY_HOME}/framework/play-1.2.7.jar"/>
            <!--<pathelement location="${your.path}"   />-->
            <pathelement location="${build.dir}"   />
        </path>
        <taskdef resource="scala/tools/ant/antlib.xml">
            <classpath>
                <pathelement location="${env.SCALA_HOME}/lib/scala-compiler.jar"/>
                <pathelement location="${env.SCALA_HOME}/lib/scala-reflect.jar"/>
                <pathelement location="${scala-library.jar}"/>
                <pathelement location="${env.PLAY_HOME}/framework/play-1.2.7.jar"/>

            </classpath>
        </taskdef>
    </target>

    <target name="build" depends="init">
        <mkdir dir="${build.dir}"/>
        <echo>build.dir:  ${build.dir}</echo>
        <scalac srcdir="/home/vf-root/workspaces/partnerspace/ipp-partner"
                destdir="${build.dir}"
                classpathref="build.classpath">
        </scalac>
    </target>

使用延迟时

延迟对象只有一个“分区”，因此计算和持久性更加可互换。 Persist会给你一个懒惰的dask.delayed对象，而compute会给你一个直接的Future对象。

dask：client.persist和client.compute之间的区别

1 个答案:

使用延迟时