内部设计

内容

内部设计¶

概述¶

12个矩形块按4行3列排列。每个块包含'x'及其在表中的位置，从左上角的('x',0,0)开始，尺寸为5x8。

Dask 数组定义了一个由较小数组块组成的网格的大数组。这些数组可能是实际的数组或生成数组的函数。我们通过以下组件定义一个 Dask 数组：

一个Dask图，具有一组特殊的键来指定块，例如 ('x', 0, 0), ('x', 0, 1), ... （更多详情请参见 Dask图文档）
每个维度上的块大小序列称为 chunks ，例如 ((5, 5, 5, 5), (8, 8, 8))
一个名称，用于识别Dask图中的哪些键引用此数组，例如 'x'
一个 NumPy dtype

示例¶

>>> import dask.array as da
>>> x = da.arange(0, 15, chunks=(5,))

>>> x.name
'arange-539766a'

>>> x.__dask_graph__()
<dask.highlevelgraph.HighLevelGraph at 0x7f9f6f686d68>

>>> dict(x.__dask_graph__())  # somewhat simplified
{('arange-539766a', 0): (np.arange, 0, 5),
 ('arange-539766a', 1): (np.arange, 5, 10),
 ('arange-539766a', 2): (np.arange, 10, 15)}

>>> x.chunks
((5, 5, 5),)

>>> x.dtype
dtype('int64')

Dask 图的键¶

根据特殊约定，我们用一个形式为 (name, i, j, k) 的元组来引用数组的每个块，其中 i, j, k 是块的索引，范围从 0 到该维度中的块数。Dask 图必须包含引用这些键的键值对。此外，它还可能包含其他键值对，这些键值对是最终计算所需值所必需的（通常组织在 HighLevelGraph 中，但为了说明，这里以扁平形式显示）：

{
 ('x', 0, 0): (add, 1, ('y', 0, 0)),
 ('x', 0, 1): (add, 1, ('y', 0, 1)),
 ...
 ('y', 0, 0): (getitem, dataset, (slice(0, 1000), slice(0, 1000))),
 ('y', 0, 1): (getitem, dataset, (slice(0, 1000), slice(1000, 2000)))
 ...
}

Array 对象的名称可以在 name 属性中找到。可以通过 .__dask_keys__() 方法获取键的嵌套列表。此外，可以使用 dask.array.core.flatten() 将此列表展平。这在构建新字典时有时很有用。

块¶

我们还存储每个块沿每个轴的大小。这由一个元组的元组组成，使得外部元组的长度等于数组的维数，内部元组的长度等于沿每个维度的块数。在上面的示例中，此值如下:

chunks = ((5, 5, 5, 5), (8, 8, 8))

请注意，这些数字不一定需要是规则的。我们经常创建规则大小的网格，但块在复杂切片后会改变形状。请注意，某些操作确实期望块形状具有一定的对称性。例如，矩阵乘法要求两侧的块具有反对称形状。

chunks 反映我们数组属性的几种方式：

len(x.chunks) == x.ndim: 块的长度是维度的数量
tuple(map(sum, x.chunks)) == x.shape: 每个内部块的总和是该维度的大小
每个内部块的长度是该维度中的键的数量。例如，对于 chunks == ((a, b), (d, e, f)) 和 name == 'x' ，我们的数组有以下键的任务:
```
('x', 0, 0), ('x', 0, 1), ('x', 0, 2)
('x', 1, 0), ('x', 1, 1), ('x', 1, 2)
```

元数据¶

许多数组操作依赖于知道 dtype（整数、浮点数等）和类型（numpy、cupy等）。为了跟踪这些信息，所有 Dask 数组对象都有一个 _meta 属性，该属性包含一个具有相同 dtypes 的空 Numpy 对象。例如：

>>> np_array = np.arange(15).reshape(3, 5)
>>> da_array = da.from_array(np_array, npartitions=2)
>>> da_array._meta
Empty Array
Shape: (0, 0)
dtype: int64
array([], shape=(0, 0), dtype=int64)

>>> ddf._meta.dtype
dtype: int64

在内部，Dask Array 尽其所能通过所有操作传播这些信息，因此大多数情况下用户不必担心这一点。

创建一个数组对象¶

为了创建一个 da.Array 对象，我们需要一个带有这些特殊键的图:

layer = {('x', 0, 0): ...}
dsk = HighLevelGraph.from_collections('x', layer, dependencies=())

指定此数组引用的键的名称:

name = 'x'

和一个 chunks 元组:

chunks = ((5, 5, 5, 5), (8, 8, 8))

然后，使用这些元素，可以构造一个数组:

x = da.Array(dsk, name, chunks)

简而言之，dask.array 操作会更新 Dask 图、更新数据类型，并跟踪块形状。

示例 - `eye` 函数¶

作为一个例子，让我们为 dask.array 构建 np.eye 函数来生成单位矩阵：

def eye(n, blocksize):
    chunks = ((blocksize,) * (n // blocksize),
              (blocksize,) * (n // blocksize))

    name = 'eye' + next(tokens)  # unique identifier

    layer = {(name, i, j): (np.eye, blocksize)
                           if i == j else
                           (np.zeros, (blocksize, blocksize))
             for i in range(n // blocksize)
             for j in range(n // blocksize)}
    dsk = dask.highlevelgraph.HighLevelGraph.from_collections(name, layer, dependencies=())

    dtype = np.eye(0).dtype  # take dtype default from numpy

    return dask.array.Array(dsk, name, chunks, dtype)

重叠计算

稀疏数组