当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


Python dask.array.core.blockwise用法及代码示例


用法:

dask.array.core.blockwise(func, out_ind, *args, name=None, token=None, dtype=None, adjust_chunks=None, new_axes=None, align_arrays=True, concatenate=None, meta=None, **kwargs)

张量运算:广义内积和外积

可以使用简洁的multi-index 表示法指定一大类阻塞算法和模式。 blockwise 函数以多种方式跨多个输入的多个块应用in-memory 函数。许多 dask.array 操作是块的特殊情况,包括元素、广播、缩减、张量点和转置。

参数

func可调用的

应用于单个块元组的函数

out_ind可迭代的

输出的块模式,例如 ‘ijk’ 或 (1, 2, 3)

*args数组序列,索引对

序列如 (x, ‘ij’, y, ‘jk’, z, ‘i’)

**kwargsdict

传递给函数的额外关键字参数

dtypenp.dtype

结果数组的数据类型。

concatenate布尔型,仅关键字

如果 true 沿虚拟索引连接数组,则提供列表

adjust_chunksdict

要应用于块大小的函数的字典映射索引

new_axesdict,仅关键字

新索引及其维度长度

例子

来自两个数组 x 和 y 的 2D 令人尴尬的并行操作。

>>> import operator, numpy as np, dask.array as da
>>> x = da.from_array([[1, 2],
...                    [3, 4]], chunks=(1, 2))
>>> y = da.from_array([[10, 20],
...                    [0, 0]])
>>> z = blockwise(operator.add, 'ij', x, 'ij', y, 'ij', dtype='f8')
>>> z.compute()
array([[11, 22],
       [ 3,  4]])

a乘b的外积,两个一维向量

>>> a = da.from_array([0, 1, 2], chunks=1)
>>> b = da.from_array([10, 50, 100], chunks=1)
>>> z = blockwise(np.outer, 'ij', a, 'i', b, 'j', dtype='f8')
>>> z.compute()
array([[  0,   0,   0],
       [ 10,  50, 100],
       [ 20, 100, 200]])

z = x.T

>>> z = blockwise(np.transpose, 'ji', x, 'ij', dtype=x.dtype)
>>> z.compute()
array([[1, 3],
       [2, 4]])

上面的转置案例是说明性的,因为它确实通过调用 np.transpose 对每个 in-memory 块进行转置,并通过切换索引 ij -> ji 的顺序对块本身的顺序进行转置。

我们可以用更多变量和更复杂的in-memory函数组合这些相同的模式

z = X + Y.T

>>> z = blockwise(lambda x, y: x + y.T, 'ij', x, 'ij', y, 'ji', dtype='f8')
>>> z.compute()
array([[11,  2],
       [23,  4]])

任何索引,例如输出索引中缺少的i,都被解释为收缩(请注意,这与 Einstein 约定不同;重复索引并不意味着收缩。)在收缩的情况下,传递的函数应该期望在任何包含该索引的数组。要接收沿收缩维度连接的数组,请传递 concatenate=True

将 a 与 b 相乘的内积,两个 1-d 向量

>>> def sequence_dot(a_blocks, b_blocks):
...     result = 0
...     for a, b in zip(a_blocks, b_blocks):
...         result += a.dot(b)
...     return result
>>> z = blockwise(sequence_dot, '', a, 'i', b, 'i', dtype='f8')
>>> z.compute()
250

使用 new_axes= 关键字添加新的 single-chunk 尺寸,包括新尺寸的长度。新维度将始终位于单个块中。

>>> def f(a):
...     return a[:, None] * np.ones((1, 5))
>>> z = blockwise(f, 'az', a, 'a', new_axes={'z': 5}, dtype=a.dtype)

通过指定块大小的元组,新维度也可以是multi-chunk。这具有有限的实用性(因为块都是相同的),但可以修改结果图以获得更有用的结果(参见da.map_blocks)。

>>> z = blockwise(f, 'az', a, 'a', new_axes={'z': (5, 5)}, dtype=x.dtype)
>>> z.chunks
((1, 1, 1), (5, 5))

如果应用的函数改变了每个块的大小,您可以使用 adjust_chunks={...} 字典来指定这一点,该字典为每个索引保存一个函数,该函数修改该索引中的维度大小。

>>> def double(x):
...     return np.concatenate([x, x])
>>> y = blockwise(double, 'ij', x, 'ij',
...               adjust_chunks={'i': lambda n: 2 * n}, dtype=x.dtype)
>>> y.chunks
((2, 2), (2,))

通过使用 None 索引来包含文字

>>> z = blockwise(operator.add, 'ij', x, 'ij', 1234, None, dtype=x.dtype)
>>> z.compute()
array([[1235, 1236],
       [1237, 1238]])

相关用法


注:本文由纯净天空筛选整理自dask.org大神的英文原创作品 dask.array.core.blockwise。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。