<h2>简短的回答</h2>
<p>只有<code>roix</code>数组是连续的。因此,使用总线从内存到CPU的传输比不连续数据的传输要快(这是因为总线在块中移动数据并缓存它们)</p>
<p>通过使其C连续<code>np.save(file, np.asarray(a, order='C'))</code>,您可以有一个小的改进(roiz大约5%,roiy大约40%)</p>
<h2>更多解释</h2>
<h2>剖析</h2>
<p>您应该使用timeit来计时您的性能,而不是自定义方法。你知道吗</p>
<p>我为你做了这些来展示一个例子:</p>
<p>在我们的牢房里:</p>
<pre><code>import os
import numpy as np
import time
import matplotlib.pyplot as plt
# take a slice of the data
def slice_data(roi):
dic = {}
data = np.zeros((512,512,256))
dic['data'] = np.squeeze( data[roi[0]:roi[1]+1, roi[2]:roi[3]+1, roi[4]:roi[5]+1] )
return dic
# save slices if the data
def save_slices(roi, save=False):
var = 'data'
for i in range(0,6):
# iterate to simulate a time series of data
a = slice_data(roi)[var]
var_dir = 'save_test/'
if not os.path.exists(var_dir): os.makedirs(var_dir)
file = var_dir + '{0:04d}{1}'.format(i,'.npy')
if save is True:
np.save(file, a)
## define slices
roix=[256, 256, 0, 512, 0, 256] # yz plane slice
roiy=[0, 512, 256, 256, 0, 256] # xz plane slice
roiz=[0, 512, 0, 512, 128, 128] # xy plane slice
</code></pre>
<p>在其他方面:</p>
<pre><code>%%timeit -n 100
save_slices(roix) # 19.8 ms ± 285 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%%timeit -n 100
save_slices(roiy) # 20.5 ms ± 948 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%%timeit -n 100
save_slices(roiz) # 20 ms ± 345 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
</code></pre>
<p>有了拯救</p>
<pre><code>%%timeit -n 10 -r 3
save_slices(roix, True) # 32.7 ms ± 2.31 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)
%%timeit -n 10 -r 3
save_slices(roiy, True) # 101 ms ± 2.61 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)
%%timeit -n 10 -r 3
save_slices(roix, True) # 1.9 s ± 21.1 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)
</code></pre>
<p>你已经注意到了,你已经注意到了!
让我们进入<code>np.save()</code>方法</p>
<h2>你知道吗Np.保存方法</h2>
<p><code>np.save</code>负责io流,并调用<a href="https://github.com/numpy/numpy/blob/d7e1fcbc2cd9e7a1eea5e04d8fee5909b07b8076/numpy/lib/format.py#L633" rel="nofollow noreferrer">write_array</a>方法。这对于Cèu连续阵列来说非常快。(快速存取存储器)</p>
<p>让我们来验证这个假设:</p>
<pre><code>np.squeeze( np.zeros((512,512,256))[roix[0]:roix[1]+1, roix[2]:roix[3]+1, roix[4]:roix[5]+1] ).flags.c_contiguous # returns True
</code></pre>
<pre><code>np.squeeze( np.zeros((512,512,256))[roiy[0]:roiy[1]+1, roiy[2]:roiy[3]+1, roiy[4]:roiy[5]+1] ).flags.c_contiguous # returns False
</code></pre>
<pre><code>np.squeeze( np.zeros((512,512,256))[roiz[0]:roiz[1]+1, roiz[2]:roiz[3]+1, roiz[4]:roiz[5]+1] ).flags.c_contiguous # returns False
</code></pre>
<p>所以这可能解释了<code>roix</code>和<code>roiy</code>/<code>roiz</code>之间的区别。你知道吗</p>
<h2>对<code>roiy</code>和<code>roiz</code>之间差异的潜在解释。数据传输速度减慢</h2>
<p>在那之后,我只能做出假设,<code>roiz</code>似乎比<code>roiy</code>更零碎。对于<code>write_array</code>方法,这需要很多时间。你知道吗</p>
<p>我现在不能自己测试这个,但是这个部分可以在linux中使用<code>perf</code>命令进行验证。(要查看使用的时间总线的数量,例如缓存未命中的数量)。
如果我不得不胡乱猜测的话,我会说缓存未命中率很高,因为数据不是连续的。因此,将数据从RAM传输到CPU确实会减慢进程。你知道吗</p>
<h2>其他处理存储的方法</h2>
<p>我没有试过,但是有一个很好的问题和一些有用的答案:<a href="https://stackoverflow.com/questions/9619199/best-way-to-preserve-numpy-arrays-on-disk">best way to preserve numpy arrays on disk</a></p>