我正在尝试找到最快的方法将一堆图像从目录中读取到numpy数组中。我的最终目标是计算统计数据，例如所有这些图像中像素的最大、最小和第 n 个百分位数。当来自所有图像的像素都在一个大的 numpy 数组中时，这是简单而快速的，因为我可以使用内置的数组方法，例如.max和.min，以及np.percentile函数。
下面是一些具有 25 个 tiff-image(512x512 像素)的示例计时。这些基准测试来自在 jupyter-notebook 中使用%%timit。差异太小，仅对25张图像没有任何实际影响，但我打算在未来阅读数千张图像。
# Imports
import os
import skimage.io as io
import numpy as np
追加到列表
%%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)使用字典
%%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 毫秒。
沿第一维实时分配一个 numpy 数组
%%timeit imgs = np.ndarray((512*25,512), dtype='uint16') img_path = '/path/to/imgs/' for num, img in enumerate(os.listdir(img_path)): imgs[num*512:(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)沿第三维预置 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毫秒。
我对此有三个问题：
- 为什么 numpy 预分配方法不比字典和列表解决方案快？
- 将数千张图像读取到一个大的 numpy 数组中的最快方法是什么？
- 我可以从 numpy 和 scikit-image 之外查看更快读取图像的模块中受益吗？我尝试了
plt.imread()，但scikit-image.io模块更快。
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..]遵循行主顺序。
应用2 ：
[[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..]。
应用3 ：
[[[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要快得多。
作为测试，我从维基页面下载了蒙娜丽莎的图像并测试了图像读取的性能 -
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
在这种情况下，大部分时间将花费在从磁盘读取文件上，我不会太担心填充列表的时间。
无论如何，这里有一个比较四种方法的脚本，没有从磁盘读取实际图像的开销，而只是从内存中读取一个对象。
import numpy as np
import time
from functools import wraps
x, y = 512, 512
img = np.random.randn(x, y)
n = 1000
def timethis(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
r = func(*args, **kwargs)
end = time.perf_counter()
print('{}.{} : {} milliseconds'.format(func.__module__, func.__name__, (end - start)*1e3))
return r
return wrapper
@timethis
def static_list(n):
imgs = [None]*n
for i in range(n):
imgs[i] = img
return imgs
@timethis
def dynamic_list(n):
imgs = []
for i in range(n):
imgs.append(img)
return imgs
@timethis
def list_comprehension(n):
return [img for i in range(n)]
@timethis
def numpy_flat(n):
imgs = np.ndarray((x*n, y))
for i in range(n):
imgs[x*i:(i+1)*x, :] = img
static_list(n)
dynamic_list(n)
list_comprehension(n)
numpy_flat(n)
结果显示：
__main__.static_list : 0.07004200006122119 milliseconds
__main__.dynamic_list : 0.10294799994881032 milliseconds
__main__.list_comprehension : 0.05021800006943522 milliseconds
__main__.numpy_flat : 309.80870099983804 milliseconds
显然，您最好的选择是列表理解，但是即使填充了numpy数组，读取1000张图像(从内存中)也只有310毫秒。因此，开销将是磁盘读取。
为什么 numpy 更慢？
这是 numpy 在内存中存储数组的方式。如果我们修改 python 列表函数以将列表转换为 numpy 数组，则时间相似。
修改后的函数返回值：
@timethis
def static_list(n):
imgs = [None]*n
for i in range(n):
imgs[i] = img
return np.array(imgs)
@timethis
def dynamic_list(n):
imgs = []
for i in range(n):
imgs.append(img)
return np.array(imgs)
@timethis
def list_comprehension(n):
return np.array([img for i in range(n)])
以及计时结果：
__main__.static_list : 303.32892100022946 milliseconds
__main__.dynamic_list : 301.86925499992867 milliseconds
__main__.list_comprehension : 300.76925699995627 milliseconds
__main__.numpy_flat : 305.9309459999895 milliseconds
所以这只是一件需要更多时间的事情，而且它是相对于数组大小的常量值......
我想你可以尝试使用glob.glob，什么应该有帮助
image_list = []
with open('train_train_.csv', 'w') as csv_file:
csv_writer = csv.writer(csv_file, delimiter ='-')
for filename in glob.glob(r'C:your path tofile*.png'):
img = cv2.imread(filename)
image_list.append(img)
csv_writer.writerow(img)
print(img)
干杯