найкращий спосіб зберегти нудні масиви на диску

Я шукаю швидкий спосіб зберегти великі масивні масиви. Я хочу зберегти їх на диску у двійковому форматі, а потім відносно швидко прочитати їх у пам'яті. cPickle не досить швидко, на жаль.

Я знайшов numpy.savez і numpy.load . Але дивна річ, що numpy.load завантажує файл npy у "карту пам'яті". Це означає, що регулярне маніпулювання масивами дійсно повільне. Наприклад, щось подібне було б справді повільним:

#!/usr/bin/python
import numpy as np;
import time; 
from tempfile import TemporaryFile

n = 10000000;

a = np.arange(n)
b = np.arange(n) * 10
c = np.arange(n) * -0.5

file = TemporaryFile()
np.savez(file,a = a, b = b, c = c);

file.seek(0)
t = time.time()
z = np.load(file)
print "loading time = ", time.time() - t

t = time.time()
aa = z['a']
bb = z['b']
cc = z['c']
print "assigning time = ", time.time() - t;

точніше, перший рядок буде дійсно швидким, але решта рядків, які призначають масиви obj, смішно повільні:

loading time =  0.000220775604248
assining time =  2.72940087318

Чи є кращий спосіб збереження нумерованих масивів? В ідеалі я хочу мати можливість зберігати кілька масивів в одному файлі.

Я великий фанат hdf5 для зберігання великих масивних масивів. Є два варіанти роботи з hdf5 в python:

http://www.pytables.org/

http://www.h5py.org/

Обидва розроблені для ефективної роботи з нумеровими масивами.

Я порівняв продуктивність (простір та час) для кількох способів зберігання нумерованих масивів. Мало хто з них підтримує кілька масивів у файлі, але, мабуть, це корисно в будь-якому випадку.

Npy та бінарні файли є дійсно швидкими та малими для щільних даних. Якщо дані рідкісні або дуже структуровані, можливо, ви хочете використовувати npz зі стисненням, що заощадить багато місця, але коштує певного часу завантаження.

Якщо портативність є проблемою, двійковий файл краще, ніж npy. Якщо читабельність людини важлива, то вам доведеться пожертвувати великою продуктивністю, але це можна досягти досить добре, використовуючи csv (що, звичайно, також дуже портативно).

Більш детальну інформацію та код можна отримати на репозиторії github .

Зараз існує клонований на основі HDF5 pickleвиклик 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' ]
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:

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

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

        else:
            time_start = time.time()
            pickle.dump( data[key], eval(compression).open( 'data.pkl.{}'.format(compression), 'wb' ) )
            time_tot = time.time() - time_start
            sizes[key][ labels[ compressions.index(compression) ] ] = ( os.path.getsize( 'data.pkl.{}'.format(compression) ) * 10**(-6), time_tot )
            os.remove( 'data.pkl.{}'.format(compression) )


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()

Щоб зберегти декілька масивів в одному файлі, потрібно просто спершу відкрити файл, а потім зберегти або завантажити масиви послідовно.

Ще одна можливість ефективно зберігати нумерові масиви - це 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')