Beschleunigen Sie das Laden von Python-Bildern

Bei der Bildverarbeitung und dem bildbasierten Deep Learning tritt häufig der Prozess des Lesens eines Bildes auf.

Wenn es sich um Hunderte von Blättern handelt, dauert es einige Minuten, um es zu lesen, wenn es auf der Skala von Zehntausenden liegt, und wenn es nur einmal ist, wenn es für Experimente mehrmals gelesen wird, ist es sogar noch schneller.

Hier werden wir mehrere Bibliotheken vergleichen und Ihnen zeigen, wie Sie die Ladezeit reduzieren können.

Fazit

• ** Speichern Sie das Bild mit pickle oder np.save ** (Datengröße erhöht sich) --Verwenden Sie das neue "Pickle" -Protokoll
• Speichern Sie als np.uint8

Ausführungsumgebung

• macOS Mojave 10.14.6
• Python 3.6

Vergleich der Lesegeschwindigkeit

Die verwendete Bibliothek und die Zeit, die zum Laden eines Bildes (Erfassen von Daten als numpy.array) benötigt wurde, sind wie folgt.

Das gelesene Bild ist eine 512 x 512 PNG-Datei.

Was Numpy und Pickle betrifft, wurden die als ".npy" und ".pickle" gespeicherten Bilder im Voraus geladen, daher ist dies kein fairer Vergleich. ** Es ist eine Tabelle, in der diese Geschwindigkeit ausgegeben wird, wenn Sie das Bild im Voraus konvertieren **, und es kann nicht geschlossen werden, dass Numpy und Pickle im Allgemeinen schnell sind.

pickle kann Protokoll angeben bei pickle.dump, ** Je neuer das Protokoll, desto schneller das Lesen ** Das stimmt, also werden Bilddaten für jedes Protokoll gespeichert.

Es gibt auch eine schnelle Bibliothek wie accimage, aber ich habe sie nicht verwendet, weil sie nicht mit macOS kompatibel war.

Es gibt auch eine Option hdf5, die jedoch nicht geprüft wurde.

Der verwendete Code lautet wie folgt. (Mit Jupyter Notebook)

import cv2
import matplotlib.pyplot as plt
import pickle
import numpy as np
from keras.preprocessing import image
from PIL import Image
from skimage import io
import _pickle

def imread1(path):
    return cv2.imread(path)

def imread2(path):
    return plt.imread(path)

def imread3(path):
    img = image.load_img(path)
    return image.img_to_array(img)

def imread4(path):
    return io.imread(path)

def imread5(path):
    img = Image.open(path)
    return np.asarray(img)

def numpy_load(path):
    return np.load(path)

def pickle_load(path):
    with open(path, mode='rb') as f:
        return pickle.load(f)
    
def _pickle_load(path):
    with open(path, mode='rb') as f:
        return _pickle.load(f)

%timeit img = imread1(img_path)
%timeit img = imread2(img_path)
%timeit img = imread3(img_path)
%timeit img = imread4(img_path)
%timeit img = imread5(img_path)
%timeit img = numpy_load(npy_path)
%timeit img = pickle_load(pickle_path_1)
%timeit img = pickle_load(pickle_path_2)
%timeit img = pickle_load(pickle_path_3)
%timeit img = pickle_load(pickle_path_4)
%timeit img = _pickle_load(pickle_path_4)

Datengrößenvergleich

Die Größe eines 512x512 .png-Bildes, das mit Numpy und Pickle gespeichert wurde, ist wie folgt.

Es wurde festgestellt, dass sogar np.uint8 mehr als das Dreifache der Kapazität der Originaldaten belegt.

Wenn Sie über genügend Speicherplatz verfügen und die Lesegeschwindigkeit so weit wie möglich erhöhen möchten, ist es besser, sie einmal mit npy oder pickle zu konvertieren, damit sie leicht gelesen werden kann.