将数以千计的图像读取到一个大的numpy数组中的最快方法

Question

我试图找到最快的方法将一堆图像从目录读取到numpy数组中。我的最终目标是计算所有这些图像中像素的最大，最小和第n个百分点之类的统计信息。当所有图像中的像素位于一个大的numpy数组中时，这是直接且快速的，因为我可以使用诸如.max和的内置数组方法.min以及np.percentile函数。

以下是一些带有25张tiff图像（512x512像素）的时序示例。这些基准来自%%timit一本jupyter笔记本中的使用。差异太小，不足以对25张图像产生任何实际影响，但我打算将来阅读数千张图像。

# Imports
import os
import skimage.io as io
import numpy as np

1. 附加到列表

   %%timeit
   

   imgs = []
   img_path = ‘/path/to/imgs/’
   for img in os.listdir(img_path):
   imgs.append(io.imread(os.path.join(img_path, img)))
   
   

   32.2 ms ± 355 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

2. 使用字典

   %%timeit
   

   imgs = {}
   img_path = ‘/path/to/imgs/’
   for img in os.listdir(img_path):
   imgs[num] = io.imread(os.path.join(img_path, img))

   33.3 ms ± 402 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

对于上面的列表和字典方法，我尝试用相应的理解替换循环，并在时间上获得相似的结果。我还尝试了预分配字典键，但所花费的时间没有明显差异。为了将图像从列表传递到一个大数组，我将使用np.concatenate(imgs)，它只需要大约1毫秒。

1. 沿第一个维度预分配一个numpy数组

   %%timeit
   

   imgs = np.ndarray((51225,512), dtype=’uint16’)
   img_path = ‘/path/to/imgs/’
   for num, img in enumerate(os.listdir(img_path)):
   imgs[num512:(num+1)*512, :] = io.imread(os.path.join(img_path, img))

   33.5 ms ± 804 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

2. 沿第三维预分配一个numpy

   %%timeit
   

   imgs = np.ndarray((512,512,25), dtype=’uint16’)
   img_path = ‘/path/to/imgs/’
   for num, img in enumerate(os.listdir(img_path)):
   imgs[:, :, num] = io.imread(os.path.join(img_path, img))

   71.2 ms ± 2.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

我最初认为numpy的预分配方法会更快，因为循环中没有动态变量扩展，但是事实并非如此。我发现最直观的方法是最后一个，其中每个图像沿数组的第三个轴占据一个单独的维度，但这也是最慢的。所花费的额外时间不是由于预分配本身而引起的，预分配本身仅花费〜1
ms。

我对此有三个问题：

1. 为什么Numpy预分配方法不比字典和列表解决方案快？
2. 将数千个图像读入一个大的numpy数组中，最快的方法是什么？
3. 我可以从numpy和scikit-image之外查看，以获得更快的读取图像的模块吗？我试过了plt.imread()，但是scikit-image.io模块更快。

Answer 1

A部分：访问和分配NumPy数组

按照NumPy数组以行优先顺序存储元素的方式，每次迭代沿最后一个轴存储这些元素时，您做的正确。这些将占用连续的内存位置，因此对于访问和分配值将是最有效的。因此，像注释中提到的那样，初始化类似np.ndarray((512*25,512), dtype='uint16')或np.ndarray((25,512,512), dtype='uint16')最好的初始化。

将它们编译为用于测试时序并以随机数组（而不是图像）进行馈入的函子后，

N = 512
n = 25
a = np.random.randint(0,255,(N,N))

def app1():
    imgs = np.empty((N,N,n), dtype='uint16')
    for i in range(n):
        imgs[:,:,i] = a
        # Storing along the first two axes
    return imgs

def app2():
    imgs = np.empty((N*n,N), dtype='uint16')
    for num in range(n):    
        imgs[num*N:(num+1)*N, :] = a
        # Storing along the last axis
    return imgs

def app3():
    imgs = np.empty((n,N,N), dtype='uint16')
    for num in range(n):    
        imgs[num,:,:] = a
        # Storing along the last two axes
    return imgs

def app4():
    imgs = np.empty((N,n,N), dtype='uint16')
    for num in range(n):    
        imgs[:,num,:] = a
        # Storing along the first and last axes
    return imgs

时间-

In [45]: %timeit app1()
    ...: %timeit app2()
    ...: %timeit app3()
    ...: %timeit app4()
    ...: 
10 loops, best of 3: 28.2 ms per loop
100 loops, best of 3: 2.04 ms per loop
100 loops, best of 3: 2.02 ms per loop
100 loops, best of 3: 2.36 ms per loop

这些定时确认在一开始提出的表演理论，虽然我预期的最后一个设置时序有定时的药粥之间app3和app1，但也许从最后要到第一线，用于访问和分配的影响不是线性的。关于这一方面的更多研究可能会很有趣（在此处跟踪问题）。

为了示意性地说明，考虑我们正在存储图像数组，分别由x（图像1）和o（图像2）表示，我们将有：

应用1：

[[[x 0]
  [x 0]
  [x 0]
  [x 0]
  [x 0]]

 [[x 0]
  [x 0]
  [x 0]
  [x 0]
  [x 0]]

 [[x 0]
  [x 0]
  [x 0]
  [x 0]
  [x 0]]]

因此，在内存空间中，将是：[x,o,x,o,x,o..]遵循行优先顺序。

App2：

[[x x x x x]
 [x x x x x]
 [x x x x x]
 [o o o o o]
 [o o o o o]
 [o o o o o]]

因此，在内存空间中，它将为：[x,x,x,x,x,x...o,o,o,o,o..]。

App3：

[[[x x x x x]
  [x x x x x]
  [x x x x x]]

 [[o o o o o]
  [o o o o o]
  [o o o o o]]]

因此，在存储空间上，它将与前一个相同。

B部分：从磁盘读取图像作为数组

现在，关于读取图像的部分，我已经看到OpenCV的imread速度要快得多。

作为测试，我从Wiki页面下载了Mona Lisa的图像，并测试了图像读取的性能-

import cv2 # OpenCV

In [521]: %timeit io.imread('monalisa.jpg')
100 loops, best of 3: 3.24 ms per loop

In [522]: %timeit cv2.imread('monalisa.jpg')
100 loops, best of 3: 2.54 ms per loop