使用Dask在单个数据上运行令人尴尬的并行操作
Dask是一个用于分布式计算的开源Python库，它可以在单个数据上运行并行操作，提供了类似于NumPy和Pandas的接口。
Dask的并行操作特性可以帮助用户处理大规模数据集，将计算任务分解为多个小任务，并在多个计算节点上同时执行，从而加速计算过程。它通过延迟计算的方式，将复杂的计算任务转化为计算图，然后根据系统资源和任务依赖关系进行动态调度和执行。
在单个数据上运行令人尴尬的并行操作时，Dask可以将数据切分成多个块，然后并行地在这些块上执行操作。这种方式能够充分利用多核处理器和分布式计算资源，提高计算效率和性能。
Dask的优势在于：
- 可扩展性：Dask可以无缝地扩展到分布式计算集群，支持处理大规模数据集和复杂计算任务。
- 延迟计算：Dask的延迟计算机制可以有效地管理计算资源，避免不必要的中间结果计算，提高计算效率。
- 弹性计算：Dask可以根据计算需求自动调整计算资源的数量和规模，实现弹性计算，提高资源利用率。
- 易用性：Dask提供了与NumPy和Pandas类似的API，用户可以轻松地将现有的Python数据分析代码迁移到Dask上，无需学习新的编程模型。
Dask在以下场景中应用广泛：
- 大数据处理：Dask适用于处理大规模数据集，如数据清洗、特征提取、机器学习模型训练等任务。
- 并行计算：Dask的并行操作特性适用于需要高性能计算的任务，如科学计算、模拟仿真、图像处理等。
- 数据分析：Dask可以与其他数据处理库（如Pandas和Scikit-learn）无缝集成，提供分布式数据处理和分析能力。
- 机器学习：Dask可以与常用的机器学习库（如TensorFlow和PyTorch）集成，提供分布式机器学习训练能力。
腾讯云提供了适用于Dask的产品和服务，其中包括：
- 弹性MapReduce（EMR）：基于Hadoop和Spark的弹性计算服务，可以与Dask集成，提供大规模数据处理和分布式计算能力。了解更多：腾讯云弹性MapReduce
- 弹性容器实例（Elastic Container Instance，ECI）：提供快速部署和管理容器化应用的服务，可以用于快速部署Dask集群。了解更多：腾讯云弹性容器实例
- 弹性伸缩（Auto Scaling）：提供根据应用负载自动调整计算资源的服务，可以与Dask集成，根据任务需求自动伸缩计算集群规模。了解更多：腾讯云弹性伸缩
通过使用Dask，在单个数据上运行令人尴尬的并行操作，可以提高计算效率、节省计算资源，并应用于各种大数据处理和分布式计算场景。
相关·内容
1回答
我有一个包含json格式列的dask dataframe，我希望将该列解析为dataframe格式。
json格式的列如下所示：
{"Name": {"id": 1000, "address": "ABC", ....}},,,
所以我只想提取"Name“的值，并使它们中的每个键都是一个列，每个值都是其中的一个值，例如：
id address ...
1000 ABC
2000 DEF
3000 GHA
... ...
我想我们可以通过read_json将json文件读入dask dataframe，但是我
浏览 5提问于2020-05-14得票数 2
让我们考虑记录为一组netcdf文件的大型数据集，如下面的代码所创建的：
import xarray as xr
import numpy as np
import dask
from scipy.stats import median_absolute_deviation
import os
n_epochs = 200
n_times = 1500
n_series = 10000
def some_process_generating_sequential_data_epochs():
return np.random.rand(n_series, n_times)
os.m
浏览 3提问于2020-03-05得票数 0
我正在对一个dask数据帧train_final[categorical_var]进行虚拟编码。然而，当我运行代码时，我得到了一个内存错误。这会发生吗，因为dask应该是通过逐块加载数据来实现的。 代码如下： from dask_ml.preprocessing import DummyEncoder
de = DummyEncoder()
train_final_cat = de.fit_transform(train_final[categorical_var]) 错误： ----------------------------------------------------------
浏览 17提问于2019-02-25得票数 4
回答已采纳
1回答
我使用过的大多数数据集通常都是中等大小的(大部分小于100 k行)，因此我的代码执行时间对我来说通常不是什么大问题。
但是，最近我试图编写一个函数，它以2个dataframes作为参数(例如，m&n行)，并返回一个带有m*n行的新数据。然后，我必须对结果数据集执行一些操作。因此，即使m&n的值很小(例如每个值约为1000 )，最终的dataframe也会有超过100万行。
当我尝试对这个数据集进行简单的操作时，代码运行的时间长得令人无法忍受。具体来说，我生成的dataframe有两个带有数值的列，我需要添加一个新列，它将比较这些列的值，并将它们分类为-“大于”、“小于”、“绑定
浏览 2提问于2015-12-11得票数 1
回答已采纳
我们在大数据集上做统计等等。现在这一切都是在一台机器上完成的。我们正在研究迁移到map-reduce范例的可行性，在这种范例中，我们将数据分解为子集，对其运行一些操作，然后合并结果。
是否有任何类型的数学测试可以应用于一组操作，以确定它们所操作的数据是否可以分解？
或者在某个地方列出哪些可以分解，哪些不能分解？
例如，我不认为有一种方法可以分解标准差，但有...
编辑:添加标签
浏览 1提问于2011-12-20得票数 0
回答已采纳
1回答
我有一个需要过滤属于某个因子组的数据帧片段的用例。
例如，假设数据框如下所示：
index col1 col2
0 A 5
1 A 10
2 B 5
3 B 8
4 C 0
... and so on
我需要做的是获取df[df['col1'] == 'A']所在位置的一大块数据，然后应用另一个函数，该函数根据其他条件测试这些行，并进一步过滤这些数据。
所以我的循环现在看起来是这样的：
df_chunks = [df[df
浏览 6提问于2020-05-21得票数 2
回答已采纳
1回答
我有一个很大的数据帧，不能放入内存。因此，我在Python语言中通过dask (分布式)访问它。 我想根据数据帧中一列的条目，用gensim包训练一个Word2Vec/Doc2Vec模型，这就是为什么我构建了一个像this question一样的迭代器。 现在，gensim使用多个内核进行训练，我需要指定其数量，类似地，dask也允许我使用多个内核。到目前为止，我把所有可用的内核都给了dask，给了gensim相同数量的内核。我的推理是，获取数据和对数据进行训练是不能同时完成的独占任务，所以gensim和dask不应该争夺核心。 实际上，没有错误消息，但培训似乎相当缓慢，我怀疑有更好的方法来
浏览 21提问于2020-01-14得票数 0
这个问题说明了一切。在我看来，向量化与令人尴尬的并行问题密切相关。换句话说，所有可向量化的程序都必须是令人尴尬的并行程序。这是正确的吗？
浏览 0提问于2013-01-10得票数 4
1回答
我正在尝试执行以下图表：
它由以下代码生成：
energies = [10, 20]
system = delayed(make_non_serializable_oject)(x=1)
trans = [delayed(some_function_that_uses_system)(system, energy) for energy in energies]
result = delayed(list)(trans)
result.visualize()
当我调用result.compute()时，计算永远不会完成。
调用result.compute(get=dask.async
浏览 10提问于2016-11-03得票数 1
回答已采纳
1回答
我是Pandas和Dask的新手，dataframes包着熊猫的数据文件，并共享大多数相同的函数调用。
我使用Dask来排序(Set_index)一个庞大的csv文件~1,000,000行~100列。排序之后，我使用itertuples()获取每个dataframe行，并将其与数据库中具有大约1,000,000行~100列的行进行比较。
但是它运行得很慢(大约需要8个小时)，有更快的方法吗？
我之所以使用dask，是因为它可以对非常大的csv文件进行排序，并且具有灵活的csv解析引擎。它还允许我在dataset上运行更高级的操作，并在将来解析更多的数据格式
我可以预先预测csv，但我想看看Da
浏览 3提问于2020-01-31得票数 0
回答已采纳
1回答
这里有个星火新手。最近，通过使用以下命令，我开始在本地机器上的两个核心上玩星火：
pyspark --master local[2]
我有一个393 has文本文件，它有将近一百万行。我想做一些数据操作。我正在使用PySpark内置的dataframe函数来执行简单的操作，如groupBy、sum、max、stddev。
然而，当我在完全相同的数据集上对熊猫做完全相同的操作时，熊猫似乎在潜伏期上以巨大的优势击败了火种。
我想知道这可能是什么原因。我有几个想法。
内置函数是否使序列化/反序列化过程效率低下？如果是，有什么可供选择的？
数据集是否太小，无法超过基础JVM运行spark所需的
浏览 0提问于2018-02-15得票数 33
回答已采纳
1回答
我有一个很大的数据集存储在hdf5文件中，我需要执行一些操作。
sku cente units
0 103896 1 2.0
1 103896 1 0.0
2 103896 1 5.0
3 103896 1 0.0
4 103896 1 7.0
使用dask，我可以非常快地执行统计操作。该操作耗时不到30s：
df.groupby(['center', 'sku'])['units'].agg([np.mean]).compute()
如果我想象一下DAG，一切似乎都组织得很好：
浏览 12提问于2019-11-15得票数 2
回答已采纳
我目前正在使用Pandas和星火进行数据分析。我发现Dask提供并行化的NumPy数组和Pandas DataFrame。
熊猫很容易用Python进行数据分析。但是，由于系统内存有限，我发现在Pandas中处理多个更大的数据文件很困难。
简单回答：
Apache是一个集分布式计算、SQL查询、机器学习等多种功能于一体的框架，它运行在JVM上，通常与Hadoop等其他大数据框架协同部署。..。通常，达斯克比火花更小，重量更轻。
我从了解了下面的细节
达斯克重量轻
Dask通常在一台机器上使用，但在分布式集群上也运行良好。
Dask提供并行数组、数据帧、机器学习和自定义算法。
浏览 4提问于2016-08-10得票数 101
2回答
我有一个包含n h5文件的目录，每个目录都有要过滤的m图像堆栈。对于每幅图像，我将使用dask并行阵列运行滤波(高斯和拉普拉斯)，以加快处理速度()。我将通过apply_parallel()函数在scikit-映像中使用dask数组。
我将使用20 cpus在小型服务器上运行处理。
--我想得到一个建议，建议使用哪种并行策略更有意义：
1) h5文件的顺序处理和用于dask处理的所有cpus
2)用h5内核并行处理x文件，并使用剩余的20-x进行dask处理。
3)对h5文件、h5文件中的图像以及dask的剩余资源进行分配和并行处理。
谢谢你的帮助！
浏览 6提问于2016-02-10得票数 2
回答已采纳
我正在为编写一个测试应用程序，我需要一个简单的、令人尴尬的并行算法，该算法易于理解，但比向输入中添加一个算法稍微简单一些。
现在，我只对只需要一个"map“步骤的算法感兴趣。或者，我只对算法的"map“步骤感兴趣。
有什么想法吗？
浏览 1提问于2012-04-24得票数 2
我有一个机器学习(ML) Linux服务器设置，多个机器学习算法在其上并行运行。ML系统是基于Python的，并安装了大多数标准ML框架和库，如TensorFlow、Sklearn、Numpy、Dask、Pandas等。
当算法同时运行时，我经常得到Resource temporarily unavailable错误，它要求我减少OMP_NUM_THREADS的值。
我想知道我是否应该减少它，因为我假设它会禁用多线程并进一步减慢算法。解决这个问题的最好方法是什么？
浏览 11提问于2021-03-01得票数 1
我只是学习达斯克和理解它的应用，以令人难堪的平行任务。我有一个函数，可以读取单个文件中的数据，并对该数据执行长时间运行的计算。我用joblib并行化加快了计算速度。
现在，我想将其扩展到多台Dask分布式机器上。我想请求一些节点，让每个机器/节点从一个文件池中处理一个文件并返回结果。我希望每个文件的处理利用某种本地节点并行。
如果这是MPI+OpenMP，我将在每台机器上有一个级别和物理内核的数量作为OpenMP线程的每一个等级。使用Dask，我只看到如何创建一个巨大的员工池来共享每个文件或所有文件的处理。我希望复合并行(每个节点一个文件，每个节点帮助处理每个文件的ncore进程)
我试着用d
浏览 0提问于2019-09-06得票数 0
回答已采纳
1回答
我想知道在这些配置下最好使用哪一个并行处理库：
一台四芯机器。我想在每个核心上执行四个相同类型的函数。相同的函数采用不同的参数。
一个由4台机器组成的集群，每台机器都有多核。我想执行相同的功能，但n并行(4台机器*没有核心在每台机器)。所以我想把它放大。
节目详情：
C++程序函数之间不存在依赖关系。使用不同的输入集执行相同的函数并完成> 100次。
没有共享内存，因为每个函数都有自己的数据和输入。
每个函数都不需要等待他人完成。不需要连接或叉子。
对于上面的场景，什么是最好的并行库可以使用？MPI，BOOST::MPI，打开mp或其他库。
我更喜欢的
浏览 2提问于2013-07-12得票数 1
我正在尝试从一大串CSV文件(目前的12个文件，8-10百万行和50列)创建一个。他们中的几个可能会融入我的系统记忆，但他们都肯定不会，因此使用达克而不是普通的熊猫。
因为读取每个csv文件需要一些额外的工作(从文件路径中添加带有数据的列)，所以我尝试从一个延迟对象列表(类似的dask.dataframe )创建。
这是我的密码：
import dask.dataframe as dd
from dask.delayed import delayed
import os
import pandas as pd
def read_file_to_dataframe(file_path):
浏览 4提问于2016-12-21得票数 8
回答已采纳
我正在使用大型CSV (~60 in；~250M行)和Dask in Jupyter。 加载DF后，我要做的第一件事是连接两个字符串列。我可以成功地做到这一点，但是我注意到单元执行时间似乎并没有随着工作进程数量的增加而减少(我在一台具有64个逻辑核心的机器上尝试了5、10和20 )。如果说有什么不同的话，那就是每五个左右的工人似乎就会增加一分钟的执行时间。 同时，Dask仪表板的进度条表明，任务与工作人员数量有很好的比例关系。在5个工作进程中，任务完成(ac。到仪表板)大约需要10-15分钟。在20个工人中，流可视化建议在大约3-5分钟内完成任务。但单元执行时间保持在25分钟左右，即在5-w
浏览 21提问于2021-07-23得票数 1
回答已采纳
1回答
如何在dask数据帧上使用pandas的pd.rank()函数。或者，在dask中有没有其他的内置函数可以做同样的事情。
浏览 11提问于2019-10-23得票数 1
回答已采纳
我们正在使用Beam的Java SDK 2.0.0在ParDo中生成顺序索引。就像Beam的中的简单有状态索引示例一样，我们使用一个ValueState<Integer>单元格，我们对它的唯一操作是在需要下一个索引时检索值和增量：
Integer statefulIndex = firstNonNull(index.read(), 0);
index.write(statefulIndex + 1);
当使用谷歌的数据流运行器运行时，我们在数据流监控界面上注意到，该ParDo的挂起时间与经过的时间同步累积。通过ssh进入工作节点并使用top和1查看每个核心的ParDo使用情况，我们
浏览 15提问于2017-06-28得票数 3
1回答
我正在尝试使用Python中的Dask合并许多大型数据集，以避免加载问题。我想将合并后的文件另存为.csv。事实证明，这个任务比想象的要难：
我用两个数据集组合了一个玩具示例，然后我使用的代码如下所示：
import dask.dataframe as dd
import glob
import os
os.chdir('C:/Users/Me/Working directory')
file_list = glob.glob("*.txt")
dfs = []
for file in file_list:
ddf = dd.read_tab
浏览 1提问于2018-11-15得票数 0
3回答
没有使用所有的核心吗？其他选择？
、、、、
我有一个python脚本，它执行以下操作: i。它接受数据的输入文件(通常是嵌套的JSON格式) ii。将数据逐行传递给另一个函数，该函数将数据操作成所需的格式iii。最后，它将输出写入文件中。
下面是我现在做这个的简单python行..。
def manipulate(line):
# a pure python function which transforms the data
# ...
return manipulated_json
for line in f:
components.append(manipulate(ujson.loads(lin
浏览 7提问于2015-12-03得票数 8
回答已采纳
1回答
我已经生成了两个长度为450,000,000的随机dask数组，我想把它们除以另一个。当我去计算它们时，计算总是在最后冻结。
我有一个运行代码的8核心32 to实例。
我已经尝试了下面的代码，并且我尝试过的一些修改并不是将数据保存在x或y中。
x = da.random.random(450000000, chunks=(10000,))
x = client.persist(x)
z1 = dd.from_array(x)
y = da.random.random(450000000, chunks=(10000,))
y = client.persist(y)
z2 = dd.from_
浏览 0提问于2018-12-22得票数 1
回答已采纳
我需要对大约1400万个用户运行DBSCAN集群，每个用户都有1k个数据点。每个用户都是一个完全独立于其他用户的不同聚类案例。基本上，我有许多小的集群任务。
在一台机器上运行它对我来说是行不通的，即使是在使用python多处理模块并行任务时，因为IO和集群需要很长时间。
我考虑过使用Spark来管理集群上的并行运行，但我认为这可能不适合我的情况，因为DBSCAN不是在MLlib中实现的，而且我不需要并行运行每个集群任务，而是单独运行每个任务。每当我尝试使用Spark原生RDD或Dataframe之外的任何东西时，它显然都必须收集到驱动程序节点的所有数据。
我的问题是，是否有更聪明的解决方案来解
浏览 53提问于2018-07-15得票数 1
1回答
我是使用#dask进行数据分析的新手。我有一些关于#dask内部如何工作的问题。例如，它如何执行I/O？就像在HDF5中一样，它是在工人中还是在其他地方并行地完成HDF5？
浏览 0提问于2020-08-06得票数 0
回答已采纳
有人问我这个问题，我的人也有点困惑。
问:你将如何处理比我的处理速度快一倍的数据？
我想到以下几点：
使用队列来处理这个问题。但是，如果我使用简单的队列，那么所需队列的大小就会不确定地大，而且我仍然会落后。随着时间的推移，我将有一半以上的数据，我可以处理。我会继续成倍增长。
我使用一个线程来读取数据，另外两个线程用于处理。但是，假设我的数据必须按顺序处理，那么会发生什么。
我仍然感到困惑，对类似问题的任何帮助都将受到欢迎。我知道可能有一个标准的解决方案，但我不知道同样的。
我想在c/c++中实现。
浏览 3提问于2015-02-26得票数 0
我有以下python脚本，其中我使用现有的pandas数据帧创建了一个dask数据帧。我使用的是多进程调度器，因为我的函数使用纯python。调度器创建8个进程(每个分区一个)，但它们是按顺序运行的，一次一个。
dask_data = ddf.from_pandas(data, npartitions=8)
dask_data = dask_data.assign(
images_array_1=dask_data.images_array_1.apply(lambda x: [] if x == "" else [int(el) for el in x.split(
浏览 4提问于2016-06-29得票数 1
1回答
我需要将SQL表中的条目读取到dask数据帧中，以处理我需要读取的条目数量可能会超过内存中可以容纳的条目数量如何使用dask完成此操作？
我正在做这件事
def get_frame_from_query(query, column_names):
frames = []
batch = []
# TODO ask stackoverflow about this.
for row in database_conn.FetchManyIter(query,batch_size=30000): #read from the database 30k rows at
浏览 13提问于2020-03-04得票数 1
回答已采纳
1回答
该算法需要相当长的时间才能对具有适度参数的大数据集进行训练：
https://stats.stackexchange.com/questions/37370/random-forest-computing-time-in-r
https://stackoverflow.com/questions/34997134/random-forest-tuning-tree-depth-and-number-of-trees
https://stackoverflow.com/questions/31278688/how-can-you-reduce-the-default-ntree-500-para
浏览 0提问于2020-01-01得票数 5
1回答
我使用dask来延迟一些函数的计算，这些函数在我的代码库中返回序列。到目前为止，除了我使用np.average之外，大多数操作似乎都像预期的那样运行。
我所拥有的函数返回一个pd.Series，然后我要计算一个加权平均值。
下面是一个非达克和达斯克版本：
import dask
import numpy as np
import pandas as pd
s = pd.Series([1,2,3])
a = np.average(s, weights=s)
print(a)
ds = dask.delayed(lambda: s)()
a = np.average(ds, weights=
浏览 0提问于2018-10-04得票数 4
回答已采纳
1回答
我对Dask的本地线程调度程序感兴趣。此调度程序可以使用多个线程从多维数组中“并行”加载数据块。我对I/O界问题感兴趣，所以暂时不考虑计算密集型应用。
使用Dask的存储方法从随机数组加载和保存数据的一些速度测试似乎证实了这一事实:随着块大小的增加，性能下降(据说是因为最小块增加了并行性)。在这个实验中，我使用没有物理块的hdf5文件:1包含数组中所有数据的数据集。
我面临的问题有两个: 1)在HDD上读取数据时，Dask如何具有并行性? 2)如果python同时阻止线程在内存中保存数据，那么Dask在读取数据时如何具有并行性？
谢谢您抽时间见我。
浏览 4提问于2019-11-02得票数 2
回答已采纳
所以我有一个包含160M记录和240列的拼图文件。因此，我使用dask在python中使用EMR CLuster m5.12xlarge加载它。
import dask.dataframe as dd
df = dd.read_parquet(file)
现在我需要其中一列的值计数和归一化值计数：
count = df.a.value_counts()
percent = df.a.value_counts(normalize = True)
a_count = dd.concat([count,percent], axis=1, keys=['counts', '%
浏览 1提问于2021-09-23得票数 0
1回答
我在达克上读到：
Worker节点和Scheduler节点同时运行。它们为多个重叠请求提供服务，同时在不阻塞的情况下执行多个重叠计算。
我一直认为单线程并发编程最适合于昂贵的I/O，而不是CPU绑定的作业。然而，我希望许多dask任务(例如dask.pandas、dask.array)都是CPU密集型的。
分布式系统是否只对客户端/服务器通信使用旋风，并有单独的进程/线程来运行dask任务？实际上，dask-worker有--nprocs和--nthreads参数，所以我希望是这样的。
如何与“旋风协同”和处理每个dask任务的更常见的进程/线程并发在分布式中？
浏览 3提问于2016-10-04得票数 4
回答已采纳
1回答
如何并行化这个耗时的循环
、、、
我正在努力寻找图像块之间的距离矩阵，矩阵的每一项都表示图像块与其他块之间的距离。我的代码运行良好，但它消耗了大量时间，需要将循环并行化。 ? def calchellinger(glcm):
tmp = np.zeros((glcm.shape[0],glcm.shape[1]))
for i in range(glcm.shape[0]):
for j in range(glcm.shape[1]):
sum = 0
for x in range(glcm.shape[0]):
浏览 10提问于2020-12-12得票数 0
回答已采纳
我有拼花文件，也就是800 K行x8.7K列。我把它装进了一个dask数据仓库：
import dask.dataframe as dd
dask_train_df = dd.read_parquet('train.parquet')
dask_train_df.info()
这产生了：
<class 'dask.dataframe.core.DataFrame'>
Columns: 8712 entries, 0 to 8711
dtypes: int8(8712)
当我尝试执行像dask_train_df.head()或dask_train_df
浏览 0提问于2018-12-24得票数 6
回答已采纳
1回答
我正在使用as_pandas实用程序从impala.util读取从hive获取的dataframe格式的数据。但是，使用熊猫，我想我将无法处理大量的数据，而且速度也会变慢。我一直在阅读dask，它为读取大数据文件提供了极好的功能。我如何使用它有效地从蜂巢中获取数据。
def as_dask(cursor):
"""Return a DataFrame out of an impyla cursor.
This will pull the entire result set into memory. For richer pandas-
like functional
浏览 2提问于2018-10-18得票数 2
回答已采纳
在将一些代码从Pandas迁移到Dask时，我发现通过使用多列调用DataFrame.assign()来修改Dask数据帧与使用多个DataFrame.__setitem__() (也称为dataframe[x]=y)调用来修改它之间存在巨大的性能差异。
使用导入
import pandas, dask, cProfile
对于定义如下的Dask数据帧：
dd = dask.dataframe.from_pandas(pandas.DataFrame({'a':[1]}), npartitions=1)
cProfile.run('for i in range(100)
浏览 3提问于2020-04-16得票数 0
我有一个非常大的数组(这里有两百万个单元格)，我想为数组中的每个单元格执行一个工作流。下面是我的测试代码： import numpy as np
import dask
from dask.distributed import Client, LocalCluster
import dask.bag as db
# invoke 8 workers
cluster = LocalCluster(n_workers=8)
client = Client(cluster)
# test workflow to be applied to each cell. The real case is
浏览 17提问于2021-08-25得票数 0
1回答
我有一张大桌子，上面有这样的字段：
CREATE UNLOGGED TABLE mytable (
ts NUMERIC(16,6) NOT NULL,
value INTEGER NOT NULL,
fieldA INTEGER NOT NULL,
fieldB INTEGER NOT NULL,
...
);
我试图找出在给定的时间间隔(1小时、6小时或1天)内，fieldA的最大和value值。换句话说，在给定的时间间隔内，我想得到每一个value的前10位和，再加上这个字段的匹配值。
查询显示超过1000个单词：
SELECT
fieldA, sum(v
浏览 0提问于2020-04-13得票数 1
回答已采纳
我试图通过Dataframe保存到与Dask调度程序/工作人员所在的同一台机器上。但是，我在这段时间里遇到了麻烦。
My安装程序：我的python脚本在本地计算机(笔记本电脑16 GB RAM)上执行，但该脚本为运行在远程计算机上的Dask调度程序(用于并行计算的具有400 GB RAM的服务器)创建了Dask客户端。Dask调度程序和工作人员都位于同一台服务器上，因此它们都共享本地可用的相同的文件系统。由于我的团队的所有成员都使用这个远程Dask调度程序，我们正在处理的文件也位于同一服务器上，通过同一个Dask集群向所有成员提供对所有文件的公共访问。
我试过：
# This saves th
浏览 2提问于2019-12-20得票数 2
回答已采纳
1回答
NBody模拟--合适的设计方法
、、、、
我有一个问题，我将有一堆nbodies每个nbodies的运动都是由现有数据预先描述的，但是当一个物体在另一个物体的范围内时，关于它的某些属性会发生变化。对于这个问题，我们假设你每个身体都有一个计数器，它计算你在其他身体周围的时间。所以基本上你从t= 0开始，你花了5秒在body 2上，所以你的t现在是5。我想知道我应该用什么方法去做，我还没有数据，但我只是想知道我是不是应该探索像CUDA/OpenCL这样的东西，或者我应该坚持在多核cpu机器上优化它。因为要模拟的数据量大约是500个物体，每个物体在30天内都有精确到秒的运动描述，所以每个物体有43200个数据点。
浏览 0提问于2012-12-05得票数 2
回答已采纳
是否有一种方法可以获得比可用内存更大的dask数组的唯一行？理想情况下，无需将其转换为dask DataFrame?。
我目前使用这种方法
import dask.array as da
import dask.dataframe as dd
dx = da.random.random((10000, 10000), chunks=(1000, 1000))
ddf = dd.from_dask_array(dx)
ddf = ddf.drop_duplicates()
dx = ddf.to_dask_array(lengths=True)
它适用于比np.unique(dx, axis=
浏览 0提问于2018-11-20得票数 5
回答已采纳
3回答
一个好的生命模拟器架构是什么？
、、、、
前几天我在想创造一个小小的生命模拟器。我只是简单地看了一下这个想法，我想知道最好的实现方式，这样它才能高效地运行。
在最底层，将会有男性和女性实体四处游荡，当他们相遇时，他们将产生后代。
我想使用多线程来管理实体，但我不确定线程的数量等。
最好是有几个线程来管理男性和女性，或者是否可以为每个实体启动一个线程，以便每个实例都在自己的线程上运行？
我读过一些关于最大线程数的帖子，限制范围从20-1000个线程在一个应用程序中。
有人对架构有什么建议吗？
N
浏览 1提问于2011-04-16得票数 2
回答已采纳
1回答
我要拿这个。
它说RDD上的减少操作一次只完成一台机器。这意味着，如果您的数据被分割到两台计算机上，那么下面的函数将在第一台计算机中处理数据，找到该数据的结果，然后从第二台计算机中取一个值，运行该函数，然后继续这样做，直到它处理完机器2中的所有值。这是正确的吗？
我认为该函数将同时在两台机器上运行，然后一旦从2台机器中得到结果，它将再次运行该函数。
rdd1=rdd.reduce(lambda x,y: x+y)
更新1
下面的步骤会给出比减少功能更快的答案吗？
Rdd=[3,5,4,7,4]
seqOp = (lambda x, y: x+y)
combOp = (lambda x, y:
浏览 3提问于2016-03-24得票数 4
1回答
当使用Dask与Dask数组时，我突然得到以下错误，并且我的内核死了/重新启动。
控制台上写着：
BLAS : Program is Terminated. Because you tried to allocate too many memory regions
我和OpenBLAS一起在mac上使用Anaconda。有什么想法吗？
注意:这个问题是通过其他方式给我的，我在这里重复一遍，供将来参考
浏览 15提问于2017-07-13得票数 4
回答已采纳
2回答
我有几份文件。最大的一个大约有8700万行。我还有其他的，大约500K行。我正在做的一部分是加入他们，当我试图与熊猫一起做这件事时，我得到了内存问题。所以我一直在使用Dask。执行所有的连接/应用是非常快的，但是即使我知道结果数据帧只有26行，也需要5个小时才能写出csv。
我读到一些连接/应用对于Dask来说并不是最好的，但这是否意味着使用Dask会更慢？因为我的速度非常快。我在数百万行上进行的所有计算/操作只需要几秒钟。但这需要永远写出来。有什么想法可以加速这个过程/为什么会发生这种情况？
浏览 27提问于2020-05-05得票数 0
1回答
我在ETL中使用dask而不是pandas，即从S3存储桶中读取CSV，然后进行一些所需的转换。Until here - dask读取和应用转换的速度比pandas快！
最后，我使用to_sql将转换后的数据转储到Redshift。在dask中这个to_sql转储比在pandas中花费更多的时间。
有没有可能缩短这段时间？如果不是，为什么在这种情况下dask比熊猫慢？
浏览 2提问于2021-09-27得票数 1
2回答
使用dask.to_parquet(df, filename)时，将创建一个子文件夹filename，并将多个文件写入该文件夹，而pandas.to_parquet(df, filename)仅写入一个文件。我可以使用dask的to_parquet (不使用compute()来创建pandas df)来只写一个文件吗？
浏览 34提问于2020-04-09得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
