2

我正在将数据写入一个 3D 数据集，我注意到一个非常令人不安的问题。我想将 20 个 2000x2000 的矩阵写入数据集中。我注意到写入 2000x2000x20 的数据集比写入 20x2000x2000 的数据集要慢得多。有谁知道为什么？

慢 - 时间：66.4123821259

import h5py
import numpy as np

file1 = h5py.File('/home/serra/Documents/Software/Store_testdata/TestDataset.h5')
a = file1.create_group('run')
b = a.create_dataset('seq_1',(2000,2000,20))

for i in range(20):
    b[:,:,i] = np.random.rand(2000,2000)

file1.close()

快速-时间：3.72713208199

import h5py
import numpy as np

file1 = h5py.File('/home/serra/Documents/Software/Store_testdata/TestDataset.h5')
a = file1.create_group('run')
b = a.create_dataset('seq_1',(20,2000,2000))

for i in range(20):
    b[i,:,:] = np.random.rand(2000,2000)

file1.close()
4

2 回答 2

3

性能差异与矩阵的大小无关，而与填充数据的顺序有关：

b[i,:,:] = np.random.rand(2000,2000)
b[:,:,i] = np.random.rand(2000,2000)

在第一种情况下，您正在填充内存中连续的单元格。在第二种情况下，细胞分散在内存中。

当项目在连续内存中时，所有相邻单元可能会在它们中的第一个被获取时被缓存。在另一种情况下，当一个被提取时，它的大部分将被保存在缓存中的相邻单元将不会被使用。

出于说明的目的，让我们考虑二维情况，并假设两个项目适合缓存。以下矩阵：

numpy.array('[[10, 20, 30], [40, 50, 60]]')

在内存中是这样存储的：

10 20 30 40 50 60

让我们看看当我们按行顺序迭代它时会发生什么：

a[0][0] → fetch 10 from memory (cached: 10 20)
a[0][1] → read 20 from cache
a[0][2] → fetch 30 from memory (cached: 30 40)
a[1][0] → read 40 from cache
a[1][1] → fetch 50 from memory (cached: 50 60)
a[1][2] → read 60 from cache

现在，让我们按列顺序迭代：

a[0][0] → fetch 10 from memory (cached: 10 20)
a[1][0] → fetch 40 from memory (cached: 30 40)
a[2][1] → fetch 20 from memory (cached: 10 20)
a[0][1] → fetch 50 from memory (cached: 50 60)
a[1][2] → fetch 30 from memory (cached: 30 40)
a[1][2] → fetch 60 from memory (cached: 50 60)

因此，在第一种情况下，您可以只使用三个内存访问来遍历整个矩阵，而在第二种情况下，您需要六个。根据经验，从内存中读取值比从缓存中读取要慢约 200 倍。

于 2013-11-12T15:13:52.627 回答
0

我猜测当您写入 20x2000x2000 的数据集时它更快的原因是因为进行的比较和增量/减量较少。将其视为一个 for 循环，如下所示 (2000x2000x20)：

for (int i = 0; i < 2000; i++)
{
    for (int j = 0; j < 2000; j++)
    {
        for (int k = 0; k < 20; k++)
        {
            dataset[i][j][k] = data;
        }
    }
}

比较操作数：88,004,001

增量操作数：84,002,000

在下一个循环中（20x2000x2000）：

for (int i = 0; i < 20; i++)
{
    for (int j = 0; j < 2000; j++)
    {
        for (int k = 0; k < 2000; k++)
        {
            dataset[i][j][k] = data;
        }
    }
}

比较操作次数：80,040,020

增量操作数：80,080,041

感谢我因为这个链接而制作的这个方便的功能http://umencs.blogspot.com/2013/04/optimization-of-nested-for-loops.html

void ComparisonAndIncrementCount(int nOuterLoop, int nMiddleLoop, int nInnerLoop)
{
    int nComparisonCount = 0;
    int nIncrementCount = 0;

    for (int i = 0; (++nComparisonCount) && i < nOuterLoop; i++, ++nIncrementCount)
    {
        for (int j = 0; (++nComparisonCount) && j < nMiddleLoop; j++, ++nIncrementCount)
        {
            for (int k = 0; (++nComparisonCount) && k < nInnerLoop; k++, ++nIncrementCount) {}
        }
    }

    printf("\n#No. of Increment Operations of Nested For Loop: %d", nIncrementCount);
    printf("\n#No. of Comparison Operations of Nested For Loop: %d", nComparisonCount);
}
于 2013-11-12T15:40:39.220 回答