Python Dask dicts包到Dask阵列

我需要将包含

{'imgs'：np.array（img_列表），'lables'：np.array（label_列表）}

的dask.Bag转换为两个单独的dask.array-s。 为什么我创建了包而不是直接去阵列？因为我正在通过

map（）

多次处理那个包；没有对数组执行相同的操作

现在，下面的代码适用于小数据集，但显然不适用于大数据集

images_array = da.from_array(np.array([item['images'] for item in imgs_labels_bag]), chunks=chunksize)
labels_array = da.from_array(np.array([item['labels'] for item in imgs_labels_bag]), chunks=chunksize)

如何在不将OBJ转换为numpy的情况下实现这一点

想法：

我试过Bag->Delayed->Array，但由于数组形状有问题，所以没有成功

一个选项可能是将包作为文本文件转储到磁盘上，然后作为dask.DataFrame/Array读取。示例：

b_dict.map（json.dumps）.to_textfiles（“/path/to/data/*.json”）

我可以用两袋np.array代替一袋dicts，然后试试Bag->Delayed->array

---

还有其他想法吗？

如果

项['images']

是1D numpy数组，并且您希望按以下方式平铺它们：

+---------------+
|item0['images']|
+---------------+
|item1['images']|
+---------------+
|item2['images']|
+---------------+    

那么这个就可以工作了（）：

结果:

[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]

---

我建议采取以下步骤：

制作两袋numpy阵列（您必须使用map或Pulk拉出

图像

和

标签

值）

使用

.map\u分区（np.stack）

或

.map\u分区（np.concatenate）

（取决于您关心的形状）将每个分区转换为单个numpy数组

使用

.to\u delayed

将分区转换为dask.delayed对象

通过对每个延迟对象调用

dask.array.from\u delayed

，将每个延迟对象转换为dask.array

使用

da.stack

或

da.concatenate

---

对于每个物品，物品['images']是dask数组还是numpy数组？每个行李物品是一个带有2 numpy.array的dict<代码>项目['images']。形状为（160,200,200,3）和

项目['labels']。形状

为（160，）。您的解决方案有效，但我对其性能表示怀疑。如果

b

有100万项，列表理解将按顺序循环通过100万项，对吗？我怀疑性能是否也会很好。列表理解肯定会在字典中循环。希望不是字典中的数组。我对行李的了解不足以加快计算速度。如果要计算多个数组，并且它们都依赖于同一中间层，则可以通过da.compute（x，y，z，…）同时计算所有数组，这样可以避免多次计算同一中间层。不确定是否可以对行李执行同样的操作。执行以下操作时，步骤（4）因属性错误而失败：

da.from\u delayed（splitted\u imgs\u bag.to\u delayed（），dataset\u shape，dtype=np.uint8）

。通过运行

print（列表（拆分的imgs\u bag.to\u delayed（））

它打印：

[延迟（'pulk-5d54b90928938c55156c742068524a2d'，0））

。似乎

da.from\u delayed

不会像

da.from\u delayed

.da.from\u delayed所期望的那样，生成具有键属性的对象。您必须创建许多小型dask阵列，然后在第五步中将它们堆叠在一起。好的，我明白了。我是这样做的：

images\u array=da.concatenate（[da.from\u delayed（delayed（item[0]），shape=（nr\u boxes\u per\u img，200200，3），dtype=np.uint8）用于拆分的\u imgs\u包中的项目，axis=0）

。因为我发现它太复杂了，而且仍然基于列表理解循环，所以我选择@r-zu问题作为最佳问题。非常感谢您的帮助。@Rocklin先生，我正试图了解在分布式环境中这对RAM的影响。假设您有一个np数组包，每个数组都在自己的分区中，每个数组都位于不同工作者的资源上：

bag=db.from_sequence（inputs，npartitions=len（inputs））；list_of_delays=bag.map（返回_nparray.to_delayed（）；list_of_darray=[da.from_delayed（dd，my_shape，my_dtype）表示延迟列表中的dd]；最终射线=da.stack（射线列表，轴=0）应该是数组数据永远不会减少到主进程的情况，对吗？
[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]