我有一个dask数据框，背后是拼花地板。这是1.31亿行，当我对整个帧执行一些基本操作时，它们需要几分钟 df = dd.read_parquet('data_*.pqt') unique_locations = df.location.unique() https = unique_locations.str.startswith('https:') http = unique_locations.str.startswith('http:') total_locations = len(un

我正在尝试使用Dask在数据帧上执行groupby操作。 下面的代码不起作用，但如果我从另一个控制台初始化客户机，代码似乎会起作用，即使我在仪表板（）上看不到任何东西：我的意思是，有一个仪表板，但所有的数字看起来都是空的。我在macOS上。 代码： csv文件只是由字符串列组成。我的目标是对列中包含特定值的所有行进行分组，然后使用create_node_csv（df_node）将它们保存为单独的文件（即使现在是一个伪函数）。任何其他方法都是很感激的，但我想了解这里发生了什么 运行时，控制台会多次

在我的Dask-warn配置文件中，即~.config/Dask/warn.yaml，我正在设置worker环境变量，如下所示： yarn: name: dask # Application name queue: default # Yarn queue to deploy to deploy-mode: remote # The deploy mode to use (either remote or loc

我正在使用dask逐行处理文件。然而，达斯克似乎什么都不做。我的代码逻辑如下： import dask from dask import delayed from time import sleep @dask.delayed def inc(x): sleep(1) print(x) def test(): for i in range(5): delayed(inc)(i) dask.compute(test()) 但是，控制台中没有任何输出

我想从队列（如redis）将数据附加到已发布的dask数据集上。然后其他python程序将能够获取最新的数据（例如，每秒/分钟一次），并执行进一步的操作 那可能吗 应该使用哪个附加接口？我应该先将其加载到pd.DataFrame中，还是最好使用一些文本导入器 假设的附加速度是多少？可以在一秒钟内追加1k/10k行吗 对于在dask集群内交换巨大且快速更新的数据集，还有其他好的建议吗 谢谢你的提示和建议。这里有一些选择 您可以看看streamz项目 你可以看看达斯克的 假设的附加速度是多少？可

具有消耗大约100GB内存的dask.DataFrame： ddf = client.persist(ddf) len(ddf_c.index) # 246652596 rows 现在我想使用.loc操作符过滤掉数据，但运行以下操作后，RAM消耗为165GB： ddf_c = ddf_c.loc[ddf_c.is_in_valid_set_of_combis == True] ddf_c = client.persist(ddf_c) # Now we have 165GB RAM consu

如果我从延迟对象中持久化dask数据帧： ddf=dd.from\u delayed（delayed\u列表，meta） ddf.至拼花地板（'/tmp/frame'） 然后重新阅读并创建另一个延迟列表： other_delayed_list=dd.read_parquet（'/tmp/frame'）。to_delayed（） 另一个延迟列表[i]是否总是与延迟列表[i]对应相同的对象 这在我的小测试中似乎是正确的，但这是保证吗

我想使用Daskdelayed任务来调用外部程序，该程序将其进度输出到STDOUT。在delayed中，我计划监视STDOUT，并希望使用从STDOUT提取的进度信息更新等待delayed任务的客户端进程。对于延迟的任务，是否有一种建议的方式与其客户端进程进行通信，或者我是否需要启动自己的进程？您可以使用dask中的任何一个或由dask提供的来实现这种流。根据您的描述，队列或pubsub机制似乎是最受欢迎的。您应该注意到，所有这些通常都是低频率和低容量通信的手段。Duh。。。我真不敢相信我错过了

我想知道是否有人能帮助我理解Bag对象处理分区的方式。简单地说，我正在尝试将当前在包中的项目分组，以便每个组都位于自己的分区中。让我困惑的是，Bag.groupby（）方法需要很多分区。分组函数不应该暗示这一点吗？例如，如果分组函数返回布尔值，则为两个分区 >>> a = dask.bag.from_sequence(range(20), npartitions = 1) >>> a.npartitions 1 >>> b = a.group

我正在努力决定Spark或Dask是否能为我们的工作提供更好的表现。我有一个简单的脚本，可以在数据帧上运行一些操作 我不相信我使用的分布式版本是正确的，因为时间比在本地使用dask慢得多。这是我的剧本： def CreateTransactionFile(inputFile, client): startTime = time.time() df = dd.read_csv(inputFile) mock = pd.DataFrame([[1,1, dateti

我正在设置Dask，我可以使用Dask进行多处理 但是，当我想使用预配置的Dask工作线程时，我遇到了一些问题。他们没有与我的主流程相同的导入 我在想。如何将自定义导入添加到dask工作人员中，以便所有访问这些工作人员的人员都能有效地运行。理想情况下，dask工作人员都应该具有相同的软件环境。通常，这在Dask之外通过Docker映像或网络文件系统（NFS）得到保证。还有一些其他的解决方案，如Client.upload_file，它对小脚本很有用

scriptA.py内容： import shlex, subprocess from dask.distributed import Client def my_task(params): print("params[1]", params[1]) ## prints python scriptB.py arg1 arg2 child = subprocess.Popen(shlex.split(params[1]), shell=False) child.communicate

我们可以用一些CPU和一些GPU机器一起创建一个dask集群吗。如果是，如何控制某个任务必须只在CPU机器上运行，或者某些其他类型的任务应该只在GPU机器上运行，如果没有指定，它应该选择空闲的机器 dask支持这种类型的集群吗。？控制任务在特定CPU/GPU机器上运行的命令是什么？您可以指定Dask工作进程具有某些抽象资源 dask-worker scheduler:8786 --resources "GPU=2" dask-worker scheduler:8786 --resources "

这是一项后续行动 我在分布式内存中持久化大型数据集时遇到问题。我有一个调度器在一台机器上运行，8个工人在各自的机器上运行，通过40千兆以太网和一个支持Lustre的文件系统连接 问题1： 在检查Dask状态仪表板时，我看到所有28个任务都分配给一个工人并由他处理，而其他工人什么也不做。此外，当每个任务都已完成处理且所有任务都处于“内存”状态时，集群上实际上只存储22 GB的RAM（即数据集的第一块）。对第一个块中的索引的访问速度很快，但任何其他索引都会在结果返回之前强制进行新一轮的读取和加载。这

我在HPC系统的分布式集群上使用Dask/Xarray和~150 GB的数据集。我已经完成了计算部分，大约需要30分钟。我想将最终结果保存到NETCDF4文件中，但将数据写入NETCDF文件的速度非常慢（~3hr），而且似乎无法并行运行。我不清楚Xarray中的“to_netcdf”函数是否应该支持并行写入。目前我的方法是使用NetCDF4编写一个空的netcdf文件，然后从Xarray追加数据： f_mosaic = 't1.nc' meta = {'width': dat_f.shape[

我正在使用Dasksubmit和collect范式执行以下操作： data_future = client.scatter(data, broadcast=True) futures = [] for i in range(10): futures.append(dask.submit(some_func, i, data_future)) results = dask_client.gather(futures) 在计算完成后，是否有某种方法可以在该范例中查看/可视化DAG 该模

在pandas中，我们有MLEXTEND包来执行Apriori算法，我们能为Python Dask提供类似的东西吗

我有一个问题，就是当索引到一个dask数组时，如何减少文件io，这个数组是由一个3D TIFF文件夹构建的，其中加载了dask.delayed，非常精确，类似于dask image方法：我的4D（tzyx）dask.array是由一堆dask.delayed（skimage.io.imread）构建的调用读取3D tiff堆栈 使用机会主义缓存，我可以最小化整个3D视图上的io事件（即多次调用的堆栈[0]。compute（）将只读取tiff文件一次），但如果我在不同平面上顺序索引到该堆栈中，就像

我正在使用Dask将分区拼花地板文件保存在S3存储桶上，如下所示： dd.to\u拼花地板( dd.from_pandas（df，npartitions=1）， path='s3a://测试/拼花'， “快速拼花地板”， 分区(国家),， 对象_encoding='utf8'， compression=“gzip”， write_index=False， ) 成功创建拼花地板文件；以下是目录结构： 我正在用这个拼花地板成功地制作一张黑斑羚桌子： 创建外部表tmp.countries\u fr

我有1M dask数据帧行。我正在尝试将字典值分配给数据帧的新列 df = df.assign(c=lambda x: {"a": x.a, "b": x.b}) print(df.compute()) 实现这一目标的最佳方式是什么 PS：我正在尝试使用进度条跟踪进度，其中代码的速度非常快，高达67%，并且挂起。我的CPU和内存消耗非常少，但代码正在运行，感觉好像永远都不会完成。可能是以下情况？（未经测试） 也许是下面的？（未经测试） df["c"]

延迟的对象是否由集群上的dask分发 此外，其任务图的执行是否也分布在集群上？简短的回答是肯定的 用户通过将本地Python会话连接到调度程序并提交工作进行交互，可以通过单独调用简单接口client.submit（函数，*args，**kwargs）或使用父dask库的大型数据收集和并行算法进行交互。dask库中的集合（如dask.array和dask.dataframe）提供了对复杂算法和熟悉的API（如NumPy和Pandas）的轻松访问，而简单的client.submit界面为用户提供了自

我需要工人一次处理一个任务，并在开始新的任务之前完成当前的任务。我无法做到：（1）每个工作人员在任何时候最多运行一个任务，（2）让工作人员在开始新的过程之前完成一个过程；原子事务 我在一个有40个节点的集群上使用dask.distributedclient；每个4芯和15GB ram。pipeline I进程的任务约为8-10GB，因此在一个工作上有两个任务将导致应用程序失败 我尝试使用dask worker scheduler ip:port--nprocs 1--resources proc

我成功地在管道中使用SMOTEENN和RF实现了一个模型。像这样： import random import numpy as np import pandas as pd from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import RandomizedSearchCV from sklearn.metrics import roc_curve, roc_auc_score, co

我的dask脚本运行良好，直到最后一步，将数千个数据帧连接在一起并写入CSV。内存使用立即从6GB跳到15GB以上，我收到一个错误，如“内存超过95%，重新启动工作程序”。不过我的机器有足够的内存。我有两个问题：（1）如何增加工作人员或最后一步的可用内存？（2） 中间的concat步骤会有帮助吗？如何最好地添加它们？问题代码如下所示： future = client.submit(pd.concat, tasks) future.result().to_csv(path) 你有没有看过类似的问

在运行dask工作程序之后，我看到了以下40.53 GB内存的输出。40.53 GB指的是分布式ram还是磁盘内存？谢谢 指在将多余结果溢出到磁盘之前，Dask打算在此特定工作进程上使用的内存量。这不是指磁盘，也不是指分布式内存。它仅指此特定工作进程上的物理ram。您可以使用--memory limit关键字对其进行修改 dask-worker scheduler-address:8786 --memory-limit VALUE 默认情况下，这是psutil库报告的物理内存的60%

我正在试图找到Dask配置文件的正确位置。我有一些关于配置Dask的问题 $ dask-worker --version dask-worker, version 2.3.2 Dask工作程序和Dask调度程序是共享同一配置文件还是使用不同的配置文件？ 我不清楚是否存在特定于Dask Worker和Dask Scheduler的配置变量。是否有Dask Worker和Dask Scheduler的有效配置变量列表 Dask工作程序和Dask调度程序配置文件的正确位置在哪里？ 我在我的系统和Da

DASK有一个非常强大的分布式api。据我所知，它只能支持本地python代码和模块 有人知道分布式DASK是否能支持C++的工作人员？ 我在文件里找不到任何东西 除了使用Python绑定来使用该功能之外，还有其他方法吗？< /P> < P>你是正确的，如果你想用DASK调用C++代码，你可以从Python调用它，通常意味着编写某种绑定层来方便调用。如果还有一个C API，您可以使用ctypes或cffi 理论上，调度器不知道客户和工人的语言，只要它们彼此同意，但没有人实现C++客户机/工作人员

客户端=。。。 fut=client.submitfun，args 是否有一些访问者可以从提交调用中获取参数，或者我们应该用一些东西包装 更新： 因此，在调试错误响应时，尤其是调试错误响应时，获取完整的任务规范通常非常有用。。。东西 以前，我已经为错误和参数创建了自己的包装器，并以dictstatus=…，args=…，result=…，的形式返回结果。。。格言 只是想知道是否有一个内置的模式，我应该使用或推动人们走向 正在调用客户端。请重新创建。。。不一定会提供进入已提交函数的参数 简而言之，

目前我正在使用下面的代码，但它需要太多的时间。因为我正在将dask数据帧转换为缓冲区，并使用多部分上传将其上传到s3中 def multi_part_upload_with_s3(file_buffer_obj,BUCKET_NAME,key_path): client = boto3.client('s3') s3 = boto3.resource('s3') config = TransferConfig(multipart_threshold=1024 *25,m

首先，阅读这个问题： 现在，当Dask决定由于工作进程被盗或任务失败（例如，由于每个进程的内存限制）而重新运行任务时，哪个任务结果会传递到DAG的下一个节点？我们正在使用嵌套任务，例如 @dask.delayed def add(n): return n+1 t_a = add(1) t_b = add(t_a) the_output = add(add(add(t_b))) 因此，如果其中一个任务失败或被盗，并且运行了两次，那么哪个结果会传递给DAG中的下一个节点 感兴趣人士的进

Apache Spark附带了一个包来进行TF-IDF计算，我觉得它非常方便： 是否有任何等效的方法，或者可能有一种使用Dask的方法？如果是这样，是否也可以在水平缩放的Dask（即具有多个GPU的集群）中执行此操作这也是Dask gitter上提出的问题，@stsievert给出了以下回复： 计数/散列向量器类似。它们在Dask ML中，与TFIDF相同，没有标准化/函数 我认为这将是一个很好的github问题/功能请求 这是的API链接。谢谢。。。我继续在这里创建了一个问题：

在Dask.distributed scheduler中使用Dask时，我的任务返回时出现KilledWorker异常。这些错误是什么意思？当Dask计划程序不再信任您的任务时，会生成此错误，因为当工作人员意外死亡时，此错误经常出现。它的设计目的是保护集群不受导致工作人员死亡的任务的影响，例如由于SEGFULTS或内存错误 每当某个工作进程意外死亡时，计划程序会记录该工作进程死亡时正在运行的任务。它会在其他员工身上重试这些任务，但也会将其标记为可疑。如果同一任务在多个工作线程死亡时出现，那么调度

是否可以将dask并行化封装在一个类中？在它的最终形式中，我的类在调用run之前将进行大量初始化-我将我的问题精简为框架问题。请注意，该代码适用于LocalCluster，并且类外部的分布式Calc也适用于同一HPC集群。下面是简要的代码以及相应的错误消息： import numpy as np from dask_jobqueue import PBSCluster from dask.distributed import Client from dask.distributed import

我在看Dask用户界面，试图找出每个字段的含义。但是，我无法理解下图中显示的写入字节和读取字节。此外，在某些情况下，写入字节数大于读取字节数。我找不到与此相关的任何文档。写字节和读字节到底意味着什么 我正在使用Joblib dask后端对MNIST数据运行一个简单的逻辑回归任务。 这些字段是关于进出该工作进程的网络流量的。这些是常用的计算术语，指通过网络接口写入的字节的测量，以及从网络接口读取的字节的测量 这是一种带宽利用率测量 一些工具（如Windows的资源监视器）将其称为“已发送”和“已接

我正在阅读估计器的实现（特别是dask_lightgb.core.py中的\u train\u part函数），我没有看到如何使用整个训练集来适应最终的估计器 \u train\u part函数接受布尔参数return\u model，在train函数的实现中（使用客户端.submit对每个工作人员调用\u train\u part），只有当工作人员是“主工作人员”时，return\u model才为真（其本身似乎是随机选择的Dask工作者）。从逻辑上讲，每个工作人员都会被分派整个模型训练集中的

将未来传递给Dask延迟功能以使未来保持稳定的最佳方式是什么？换句话说，我们如何确保函数将获得实际的未来，而不是它所代表的结果？通常语义是dask.delayed函数得到具体的结果，而不是dask-y函数。今天，如果没有一些技巧，这是不容易支持的 尽管如此，我还是推荐以下技巧： 把你的未来放在一个 谢谢这似乎是合理的。还发现dask.core.literal有效，使用它是否合理？人力资源管理，是的，这似乎是一个更好的主意。我建议提高PR，将其推送到顶级API中，并ping jcrist，看看他的

我正在尝试将json文件加载到dask df中 files = glob.glob('**/*.json', recursive=True) df = dd.read_json(files, lines = False) 数据中缺少一些值，并且一些文件有额外的列。 有没有办法指定一个列列表，以便所有可能的列都存在于连接的dask df中？ 此外，它不能处理缺少的值吗？我在尝试计算df时遇到以下错误： ValueError: Metadata mismatch found in `from_de

我需要通过线性插值对一些卫星图像进行采样，这些图像组织在一个数据阵列中。 在本地运行代码之前，我没有问题，但是如果我尝试在分布式系统上复制插值，我会返回以下错误： `Could not serialize object of type tuple` 要复制这个问题，需要在分布式或本地环境之间切换。 这里是代码的分布式版本 n_time = 365 px = 2000 lat = np.linspace(19., 4., px) lon = np.linspace(34., 53., px)

我想知道Dask是否是处理视频文件的好工具。在本地，我使用OpenCV一次读取一帧并处理它。我认为，如果视频的每一帧都由单独的Dask任务处理，那将是理想的。另外，对于多个时间同步的视频文件，我想知道如何从每个摄像头一次读取一帧，并在一个任务中处理两个摄像头的帧 我不认为Dask支持生成器函数，但如果它真的支持，我认为这将是理想的。生成器任务将在任务图中一次生成一帧视频 下面是一个与我正在做的类似的示例脚本。它从多个视频文件中的每个文件中取出一帧，裁剪并调整每个文件的大小到标准大小，然后将这些文

我想使用dask数据帧中的列创建一个dask系列，并将其添加到dask数据帧中。创建新系列的函数可以是任意复杂的，并且可能使用dask.dataframe没有的函数。我的想法是为该函数使用dask.delayed装饰器，并从单个delayed对象创建一个dask系列。然后，我遇到了一个问题：必须将这个新系列的分区/分区与原始dask数据帧对齐，以便将其作为列附加。我可以假设由该函数创建的序列始终具有与原始dask数据帧相同的长度和索引。所以我尝试了一些“肮脏”的伎俩来实现它。见下文： impor

我试图在Dask中找到Spark的unpersist的等价物。我的需要 对于显式非持久性，出现在以下情况： 调用上下文已经保留了一个大的df，例如，因为它需要 为预处理目的计算多个聚合 调用上下文调用一个函数，该函数也需要调用persist，例如。， 因为它执行一些迭代算法 一个基本示例如下所示： def迭代算法（df，num迭代）： 对于范围内的迭代（num_迭代）： #需要映射分区等转换逻辑 def映射器（df）： # ... 返回df df=df.map\u分区（映射器） df=df.

我有33个多分区数据帧。它们都有自己的元数据。它们都是用镶木地板做的。结构类似于： - 20190101.parquet - _common_metadata - _metadata - part.0.parquet - .... - part.n.parquet - 20190102.parquet - _common_metadata - _metadata - part.0.parquet - .... - part.n.parquet - 20190103.parqu

我发布的软件使用分布式来跨进程并行化 我想为我的用户关闭工作窃取，因为我发现它会导致一些不稳定，因为上游使用了锁 我从调度器文件（通过dask mpi创建）和本地集群为用户创建客户端对象。我如何才能在不让用户在安装过程中自己动手的情况下为用户关闭工作窃取功能？Config file 您可以在config.yaml文件中更改以下行 work-stealing: False # workers should steal tasks from each other 您还可以通过将环境变量DA

我的问题与此非常接近： 我使用“pyarrow”引擎将csv文件转换为拼花地板。 读取文件时出现架构错误。与前面的问题不同，似乎某个拼花地板文件添加了原始文件中没有的新列 ddf=dd.read\u拼花地板（“snappywork”， columns=colnames ) 回溯（最近一次呼叫最后一次）： 文件“”，第2行，在 文件“C:\Users\gunsu.son\AppData\Local\Programs\Python37\lib\site packages\dask\dataframe

我的应用程序要求我从其他任务中启动任务，如下所示 def a(): # ... some computation .. def b(): # ... some computation .. def c(): client = get_client() a = client.submit(a) b = client.submit(b) [a,b] = client.gather([a,b]) return a+b client =

我用Python扩展C++构建了一个分布式空间索引。我正在尝试使用Dask（第一次）而不是MPI。 当前的实现是可行的，但存在几个问题 与串行执行相比，关键部分是巨大的开销。我希望算法的速度几乎是线性的 Persist似乎没有达到我预期的效果，因为第一个查询的时间比第二个查询的时间长得多 在我看来，这个代码看起来很不规范，但正如我所说的，我对达斯克是新手。有更好的方法吗 当使用2d块时，我需要对延迟的对象进行索引。1d块不会出现这种情况，感觉很奇怪 该算法构建粒子排序列表，然后构建八叉树，其中节

将元参数传递给groupby.apply时，我无法重置索引并删除与索引对应的列之一。 下面是一个简单的例子： import pandas as pd import dask.dataframe as dd df = pd.DataFrame({'c0': ['a', 'b', 'a', 'a', 'b'], 'c1': [1, 1, 1, 2, 5], 'c2': [0, 1, 0, 2, 5],

我正在开发一个相当复杂的应用程序，它使用Dask框架，试图提高性能。为此，我正在查看诊断仪表板。我有两个用例。首先，我有一个1GB的拼花地板文件，分为50个部分，在第二个用例中，我有上面文件的第一部分，分为5个部分，这是用于以下图表的： 红色节点称为“memory:list”，我不明白它是什么。 当运行较大的输入时，这似乎会阻止整个操作 最后，当我进入这些节点时，我会看到： 我不确定应该从哪里开始了解是什么生成了这个memory:list节点，特别是考虑到任务中经常出现的堆栈按钮。有什么建

我以前使用pandas合并数据帧，但遇到了内存问题 我有一个巨大的数据帧，我已经使用dask合并了其他几个大数据帧。所有的read_csv和dd.merge与几个数据帧都很快，但是直到最后一步，在哪里读取csv会导致崩溃（我认为这是内存问题） 我将df1与其他四个数据帧单独合并，如下所示： df1 = dd.merge(df1,df2, on='ID', how='inner') df1 = dd.merge(df1,df3, on='ID', how='inner') df1 = dd.mer

我有一个文本文件，它被分割成多个片段，每个片段分别压缩 我希望能够以一行一行的方式处理它。但是，这些线是在片段边界上分割的，因此在解压缩之后，我需要将它们重新连接在一起 例如，如果我最初有： Finland, Finland, Finland. The country where I want to be, Pony trekking or camping, Or just watching TV, Finland, Finland, Finland. It's the country fo