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

用法: dask.array.register_chunk_type(type)

将给定类型注册为有效的块和向下转换的数组类型

参数：

type：类型: 要注册为类型的 Duck 数组类型 Dask 可以安全地包装为一个块，并且 Dask 在算术运算和 NumPy 函数/ufunc 中不会推迟到该块。

注意：

dask.array.Array 可以在其块中包含任何足够的 “NumPy-like” 数组。这些也称为“duck arrays”，因为它们匹配 NumPy 数组 API 中最重要的部分，因此在依赖鸭子类型时表现相同。

但是，为了使多个鸭子数组类型正确地互操作，它们需要根据明确定义的类型转换层次结构 (see NEP 13) 在算术运算和 NumPy 函数/ufunc 中正确地相互延迟。为了维护这种层次结构，Dask 遵循除了其内部注册表中的所有其他鸭数组类型。默认情况下，此注册表包含

numpy.ndarray
numpy.ma.MaskedArray
cupy.ndarray
sparse.SparseArray
scipy.sparse.spmatrix

此函数用于将任何其他类型附加到此注册表。如果一个类型不在此注册表中，但仍是向下转换类型(它在类型转换层次结构中位于 dask.array.Array 之下)，则由于所有操作数类型都返回 NotImplemented ，将引发 TypeError 。

例子：

使用模拟 FlaggedArray 类作为 Dask 未知的示例块类型，具有最小的鸭数组 API：

>>> import numpy.lib.mixins
>>> class FlaggedArray(numpy.lib.mixins.NDArrayOperatorsMixin):
...     def __init__(self, a, flag=False):
...         self.a = a
...         self.flag = flag
...     def __repr__(self):
...         return f"Flag: {self.flag}, Array: " + repr(self.a)
...     def __array__(self):
...         return np.asarray(self.a)
...     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
...         if method == '__call__':
...             downcast_inputs = []
...             flag = False
...             for input in inputs:
...                 if isinstance(input, self.__class__):
...                     flag = flag or input.flag
...                     downcast_inputs.append(input.a)
...                 elif isinstance(input, np.ndarray):
...                     downcast_inputs.append(input)
...                 else:
...                     return NotImplemented
...             return self.__class__(ufunc(*downcast_inputs, **kwargs), flag)
...         else:
...             return NotImplemented
...     @property
...     def shape(self):
...         return self.a.shape
...     @property
...     def ndim(self):
...         return self.a.ndim
...     @property
...     def dtype(self):
...         return self.a.dtype
...     def __getitem__(self, key):
...         return type(self)(self.a[key], self.flag)
...     def __setitem__(self, key, value):
...         self.a[key] = value

在注册 FlaggedArray 之前，两种类型都将尝试推迟到另一种：

>>> import dask.array as da
>>> da.ones(5) - FlaggedArray(np.ones(5), True)
Traceback (most recent call last):
...
TypeError: operand type(s) all returned NotImplemented ...

但是，一旦注册，Dask 将能够使用这种新类型处理操作：

>>> da.register_chunk_type(FlaggedArray)
>>> x = da.ones(5) - FlaggedArray(np.ones(5), True)
>>> x
dask.array<sub, shape=(5,), dtype=float64, chunksize=(5,), chunktype=dask.FlaggedArray>
>>> x.compute()
Flag: True, Array: array([0., 0., 0., 0., 0.])

相关用法

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