лучший способ сохранить массивы numpy на диске

Я большой поклонник hdf5 для хранения больших массивов numpy. Есть два варианта работы с hdf5 в python:

http://www.pytables.org/

http://www.h5py.org/

Оба предназначены для эффективной работы с массивами numpy.

Я сравнил производительность (пространство и время) для нескольких способов хранения массивов numpy. Некоторые из них поддерживают несколько массивов для каждого файла, но, возможно, это все равно полезно.

Тест

Npy и двоичные файлы действительно быстрые и маленькие для плотных данных. Если данные разреженные или очень структурированные, вы можете использовать npz со сжатием, что сэкономит много места, но потребует некоторого времени загрузки.

Если переносимость является проблемой, двоичный код лучше, чем npy. Если удобочитаемость для человека важна, вам придется пожертвовать большой производительностью, но этого можно довольно хорошо добиться с помощью csv (который, конечно, также очень переносим).

Дополнительные сведения и код доступны в репозитории github.

Теперь существует клон pickle на основе HDF5 под названием hickle!

https://github.com/telegraphic/hickle

import hickle as hkl 

data = {'name': 'test', 'data_arr': [1, 2, 3, 4]}

# Dump data to file
hkl.dump(data, 'new_data_file.hkl')

# Load data from file
data2 = hkl.load('new_data_file.hkl')

print(data == data2)

РЕДАКТИРОВАТЬ:

Также есть возможность скопировать прямо в сжатый архив, выполнив:

import pickle, gzip, lzma, bz2

pickle.dump(data, gzip.open('data.pkl.gz', 'wb'))
pickle.dump(data, lzma.open('data.pkl.lzma', 'wb'))
pickle.dump(data, bz2.open('data.pkl.bz2', 'wb'))

Приложение

import numpy as np
import matplotlib.pyplot as plt
import pickle, os, time
import gzip, lzma, bz2, h5py

compressions = ['pickle', 'h5py', 'gzip', 'lzma', 'bz2']
modules = dict(
    pickle=pickle, h5py=h5py, gzip=gzip, lzma=lzma, bz2=bz2
)

labels = ['pickle', 'h5py', 'pickle+gzip', 'pickle+lzma', 'pickle+bz2']
size = 1000

data = {}

# Random data
data['random'] = np.random.random((size, size))

# Not that random data
data['semi-random'] = np.zeros((size, size))
for i in range(size):
    for j in range(size):
        data['semi-random'][i, j] = np.sum(
            data['random'][i, :]) + np.sum(data['random'][:, j]
        )

# Not random data
data['not-random'] = np.arange(
    size * size, dtype=np.float64
).reshape((size, size))

sizes = {}

for key in data:

    sizes[key] = {}

    for compression in compressions:
        path = 'data.pkl.{}'.format(compression)

        if compression == 'pickle':
            time_start = time.time()
            pickle.dump(data[key], open(path, 'wb'))
            time_tot = time.time() - time_start
            sizes[key]['pickle'] = (
                os.path.getsize(path) * 10**-6, 
                time_tot.
            )
            os.remove(path)

        elif compression == 'h5py':
            time_start = time.time()
            with h5py.File(path, 'w') as h5f:
                h5f.create_dataset('data', data=data[key])
            time_tot = time.time() - time_start
            sizes[key][compression] = (os.path.getsize(path) * 10**-6, time_tot)
            os.remove(path)

        else:
            time_start = time.time()
            with modules[compression].open(path, 'wb') as fout:
                pickle.dump(data[key], fout)
            time_tot = time.time() - time_start
            sizes[key][labels[compressions.index(compression)]] = (
                os.path.getsize(path) * 10**-6, 
                time_tot,
            )
            os.remove(path)


f, ax_size = plt.subplots()
ax_time = ax_size.twinx()

x_ticks = labels
x = np.arange(len(x_ticks))

y_size = {}
y_time = {}
for key in data:
    y_size[key] = [sizes[key][x_ticks[i]][0] for i in x]
    y_time[key] = [sizes[key][x_ticks[i]][1] for i in x]

width = .2
viridis = plt.cm.viridis

p1 = ax_size.bar(x - width, y_size['random'], width, color = viridis(0))
p2 = ax_size.bar(x, y_size['semi-random'], width, color = viridis(.45))
p3 = ax_size.bar(x + width, y_size['not-random'], width, color = viridis(.9))
p4 = ax_time.bar(x - width, y_time['random'], .02, color='red')

ax_time.bar(x, y_time['semi-random'], .02, color='red')
ax_time.bar(x + width, y_time['not-random'], .02, color='red')

ax_size.legend(
    (p1, p2, p3, p4), 
    ('random', 'semi-random', 'not-random', 'saving time'),
    loc='upper center', 
    bbox_to_anchor=(.5, -.1), 
    ncol=4,
)
ax_size.set_xticks(x)
ax_size.set_xticklabels(x_ticks)

f.suptitle('Pickle Compression Comparison')
ax_size.set_ylabel('Size [MB]')
ax_time.set_ylabel('Time [s]')

f.savefig('sizes.pdf', bbox_inches='tight')

savez () сохраняет данные в zip-файле. Для того, чтобы заархивировать и распаковать файл, может потребоваться некоторое время. Вы можете использовать функции save () и load ():

f = file("tmp.bin","wb")
np.save(f,a)
np.save(f,b)
np.save(f,c)
f.close()

f = file("tmp.bin","rb")
aa = np.load(f)
bb = np.load(f)
cc = np.load(f)
f.close()

Чтобы сохранить несколько массивов в одном файле, вам просто нужно сначала открыть файл, а затем последовательно сохранить или загрузить массивы.

Еще одна возможность эффективно хранить массивы numpy - это Bloscpack:

#!/usr/bin/python
import numpy as np
import bloscpack as bp
import time

n = 10000000

a = np.arange(n)
b = np.arange(n) * 10
c = np.arange(n) * -0.5
tsizeMB = sum(i.size*i.itemsize for i in (a,b,c)) / 2**20.

blosc_args = bp.DEFAULT_BLOSC_ARGS
blosc_args['clevel'] = 6
t = time.time()
bp.pack_ndarray_file(a, 'a.blp', blosc_args=blosc_args)
bp.pack_ndarray_file(b, 'b.blp', blosc_args=blosc_args)
bp.pack_ndarray_file(c, 'c.blp', blosc_args=blosc_args)
t1 = time.time() - t
print "store time = %.2f (%.2f MB/s)" % (t1, tsizeMB / t1)

t = time.time()
a1 = bp.unpack_ndarray_file('a.blp')
b1 = bp.unpack_ndarray_file('b.blp')
c1 = bp.unpack_ndarray_file('c.blp')
t1 = time.time() - t
print "loading time = %.2f (%.2f MB/s)" % (t1, tsizeMB / t1)

и вывод для моего ноутбука (относительно старый MacBook Air с процессором Core2):

$ python store-blpk.py
store time = 0.19 (1216.45 MB/s)
loading time = 0.25 (898.08 MB/s)

это означает, что он может хранить очень быстро, то есть узким местом обычно является диск. Однако, поскольку степени сжатия здесь довольно хорошие, эффективная скорость умножается на степени сжатия. Вот размеры этих массивов 76 МБ:

$ ll -h *.blp
-rw-r--r--  1 faltet  staff   921K Mar  6 13:50 a.blp
-rw-r--r--  1 faltet  staff   2.2M Mar  6 13:50 b.blp
-rw-r--r--  1 faltet  staff   1.4M Mar  6 13:50 c.blp

Обратите внимание, что использование компрессора Blosc является основополагающим для достижения этой цели. Тот же сценарий, но с параметром clevel = 0 (т.е. отключение сжатия):

$ python bench/store-blpk.py
store time = 3.36 (68.04 MB/s)
loading time = 2.61 (87.80 MB/s)

явно узким местом из-за производительности диска.

Время поиска медленное, потому что когда вы используете mmap, чтобы не загружать содержимое массива в память, когда вы вызываете метод load. Когда требуются определенные данные, данные загружаются лениво. И в вашем случае это происходит при поиске. Но второй поиск не будет таким медленным.

Это хорошая особенность mmap, когда у вас большой массив, вам не нужно загружать все данные в память.

Чтобы решить эту проблему, вы можете использовать joblib, вы можете выгрузить любой объект, который хотите, используя joblib.dump даже два или более numpy arrays, см. пример

firstArray = np.arange(100)
secondArray = np.arange(50)
# I will put two arrays in dictionary and save to one file
my_dict = {'first' : firstArray, 'second' : secondArray}
joblib.dump(my_dict, 'file_name.dat')

«Лучшее» зависит от вашей цели. Как говорили другие, двоичный файл максимально переносим, ​​но проблема в том, что вам нужно знать, как хранятся данные.

Darr сохраняет ваш массив numpy самодокументированным способом на основе плоских двоичных и текстовых файлов. Это обеспечивает максимальную читаемость. Он также автоматически включает код о том, как читать ваш массив на различных языках науки о данных, таких как сам numpy, а также R, Matlab, Julia и т. Д.

Раскрытие информации: я написал библиотеку.