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’)
**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.core.blockwise。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。