用于读取行的最佳 HDF5 数据集块形状

问题描述：

我有一个合理大小（压缩后为 18GB）的 HDF5 数据集，并且希望优化读取行的速度。形状为 (639038, 10000)。我将多次读取位于数据集中的选定行（例如 ~1000 行）。因此，我不能使用 x:(x+1000) 来切片行。

使用 h5py 从内存不足的 HDF5 读取行已经很慢了，因为我必须传递一个排序列表并诉诸花哨的索引。有没有办法避免花哨的索引，或者有没有更好的块形状/大小可以使用？

我读过一些经验法则，例如 1MB-10MB 的块大小和选择与我所读内容一致的形状。但是，构建大量具有不同块形状的 HDF5 文件进行测试在计算上非常昂贵，而且速度非常慢。

对于每选择约 1,000 行，我都会立即将它们相加，得到一个长度为 10,000 的数组。我当前的数据集如下所示：

'10000': {'chunks': (64, 1000),
          'compression': 'lzf',
          'compression_opts': None,
          'dtype': dtype('float32'),
          'fillvalue': 0.0,
          'maxshape': (None, 10000),
          'shape': (639038, 10000),
          'shuffle': False,
          'size': 2095412704}

我已经尝试过的：

• 重写块形状为（128,10000）的数据集（我计算其大小约为5MB）的速度非常慢。

• 我查看了 dask.array 进行优化，但由于~1,000 行很容易装入内存，所以我没有看到任何好处。

解决方案 1：

找到正确的块缓存大小

首先我想讨论一些一般性的东西。了解每个单独的块只能作为一个整体进行读取或写入非常重要。h5py 的标准块缓存大小可以避免过多的磁盘 I/O，默认情况下仅为 1 MB，在许多情况下应该增加，这将在后面讨论。

举个例子：

• 我们有一个形状为 (639038, 10000) 的数据集，float32（未压缩时为 25,5 GB）

• 我们希望按列写入数据dset[:,i]=arr，按行读取数据arr=dset[i,:]

• 对于这种类型的工作，我们选择了一个完全错误的块形状，即（1,10000）

在这种情况下，读取速度不会太差（尽管块大小有点小），因为我们只读取我们正在使用的数据。但是当我们在该数据集上写入时会发生什么？如果我们访问一列，则会写入每个块的一个浮点数。这意味着我们实际上在每次迭代中写入整个数据集（25.5 GB），并且每隔一次读取整个数据集。这是因为如果您修改一个块，如果它没有缓存，您必须先读取它（我假设这里的块缓存大小低于 25.5 GB）。

那么我们可以在这里改进什么呢？在这种情况下，我们必须在写入/读取速度和块缓存使用的内存之间做出妥协。

一个能提供良好读写速度的假设：

• 我们选择块大小为（100, 1000）

• 如果我们想要迭代第一个维度，我们至少需要（10006390384 ->2,55 GB）的缓存以避免如上所述的额外 IO 开销和（100100004 -> 0,4 MB）。

• 因此，在这个例子中，我们应该提供至少 2.6 GB 的块数据缓存。

结论
没有普遍正确的块大小或形状，它在很大程度上取决于要使用哪个任务。在不考虑块缓存的情况下，切勿选择块大小或形状。就随机读/写而言，RAM 比最快的 SSD 快几个数量级。

关于你的问题，
我只会读取随机行，不适当的块缓存大小才是你的真正问题。

将以下代码与您的版本的性能进行比较：

import h5py as h5
import time
import numpy as np

def ReadingAndWriting():
    File_Name_HDF5='Test.h5'

    #shape = (639038, 10000)
    shape = (639038, 1000)
    chunk_shape=(100, 1000)
    Array=np.array(np.random.rand(shape[0]),np.float32)

    #We are using 4GB of chunk_cache_mem here ("rdcc_nbytes")
    f = h5.File(File_Name_HDF5, 'w',rdcc_nbytes =1024**2*4000,rdcc_nslots=1e7)
    d = f.create_dataset('Test', shape ,dtype=np.float32,chunks=chunk_shape,compression="lzf")

    #Writing columns
    t1=time.time()
    for i in range(0,shape[1]):
        d[:,i:i+1]=np.expand_dims(Array, 1)

    f.close()
    print(time.time()-t1)

    # Reading random rows
    # If we read one row there are actually 100 read, but if we access a row
    # which is already in cache we would see a huge speed up.
    f = h5.File(File_Name_HDF5,'r',rdcc_nbytes=1024**2*4000,rdcc_nslots=1e7)
    d = f["Test"]
    for j in range(0,639):
        t1=time.time()
        # With more iterations it will be more likely that we hit a already cached row
        inds=np.random.randint(0, high=shape[0]-1, size=1000)
        for i in range(0,inds.shape[0]):
            Array=np.copy(d[inds[i],:])
        print(time.time()-t1)
    f.close()

最简单的花式切片

我在评论中写道，在最近的版本中我看不到这种行为。我错了。比较以下内容：

def Writing()：File_Name_HDF5='Test.h5'

#shape = (639038, 10000)
shape = (639038, 1000)
chunk_shape=(100, 1000)
Array=np.array(np.random.rand(shape[0]),np.float32)

# Writing_1 normal indexing
###########################################
f = h5c.File(File_Name_HDF5, 'w',chunk_cache_mem_size=1024**2*4000)
d = f.create_dataset('Test', shape ,dtype=np.float32,chunks=chunk_shape,compression="lzf")

t1=time.time()
for i in range(shape[1]):
    d[:,i:i+1]=np.expand_dims(Array, 1)

f.close()
print(time.time()-t1)

# Writing_2 simplest form of fancy indexing
###########################################
f = h5.File(File_Name_HDF5, 'w',rdcc_nbytes =1024**2*4000,rdcc_nslots=1e7)
d = f.create_dataset('Test', shape ,dtype=np.float32,chunks=chunk_shape,compression="lzf")

#Writing columns
t1=time.time()
for i in range(shape[1]):
    d[:,i]=Array

f.close()
print(time.time()-t1)

这使得我的硬盘上第一个版本耗时 34 秒，第二个版本耗时 78 秒。