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

用法:
dask.array.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’)
**kwargs：dict: 传递给函数的额外关键字参数
dtype：np.dtype: 结果数组的数据类型。
concatenate：布尔型，仅关键字: 如果 true 沿虚拟索引连接数组，则提供列表
adjust_chunks：dict: 要应用于块大小的函数的字典映射索引
new_axes：dict，仅关键字: 新索引及其维度长度

例子：

来自两个数组 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.blockwise。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。