najlepszy sposób na zachowanie numpy tablic na dysku

Szukam szybkiego sposobu na zachowanie dużych, zdrętwiałych tablic. Chcę je zapisać na dysku w formacie binarnym, a następnie stosunkowo szybko wczytać z powrotem do pamięci. Niestety, cPickle nie jest wystarczająco szybki.

Znalazłem numpy.savez i numpy.load . Ale dziwne jest to, że numpy.load ładuje plik npy ​​do "mapy pamięci". Oznacza to, że regularne manipulowanie tablicami jest naprawdę powolne. Na przykład coś takiego byłoby naprawdę powolne:

#!/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;

dokładniej, pierwsza linia będzie naprawdę szybka, ale pozostałe linie, które przypisują tablice, objsą absurdalnie wolne:

loading time =  0.000220775604248
assining time =  2.72940087318

Czy jest lepszy sposób na zachowanie tablic numpy? W idealnym przypadku chciałbym mieć możliwość przechowywania wielu tablic w jednym pliku.

Jestem wielkim fanem hdf5 do przechowywania dużych tablic numpy. Istnieją dwie możliwości radzenia sobie z hdf5 w Pythonie:

http://www.pytables.org/

http://www.h5py.org/

Oba są zaprojektowane do wydajnej pracy z tablicami numpy.

Porównałem wydajność (przestrzeń i czas) dla wielu sposobów przechowywania tablic numpy. Niewiele z nich obsługuje wiele tablic na plik, ale być może i tak jest to przydatne.

Pliki Npy i binarne są bardzo szybkie i małe dla gęstych danych. Jeśli dane są rzadkie lub bardzo uporządkowane, możesz chcieć użyć npz z kompresją, co pozwoli zaoszczędzić dużo miejsca, ale kosztuje trochę czasu ładowania.

Jeśli problemem jest przenośność, plik binarny jest lepszy niż npy. Jeśli czytelność dla ludzi jest ważna, będziesz musiał poświęcić dużo wydajności, ale można to całkiem dobrze osiągnąć za pomocą csv (który jest oczywiście również bardzo przenośny).

Więcej szczegółów i kod są dostępne w repozytorium github .

Jest teraz oparty na HDF5 klon picklenazwany 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 )

EDYTOWAĆ:

Istnieje również możliwość "wytrawiania" bezpośrednio do skompresowanego archiwum, wykonując:

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

dodatek

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 () zapisuje dane w pliku zip, skompresowanie i rozpakowanie pliku może zająć trochę czasu. Możesz użyć funkcji 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()

Aby zapisać wiele tablic w jednym pliku, wystarczy najpierw otworzyć plik, a następnie zapisać lub załadować tablice po kolei.

Inną możliwością efektywnego przechowywania tablic numpy jest 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)

i wyjście dla mojego laptopa (stosunkowo stary MacBook Air z procesorem Core2):

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

oznacza to, że może przechowywać naprawdę szybko, tj. wąskim gardłem jest zwykle dysk. Ponieważ jednak współczynniki kompresji są tutaj całkiem dobre, efektywna prędkość jest mnożona przez współczynniki kompresji. Oto rozmiary tych 76 MB macierzy:

$ 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

Należy pamiętać, że użycie kompresora Blosc jest podstawą do osiągnięcia tego. Ten sam skrypt, ale używający „clevel” = 0 (tj. Wyłączając kompresję):

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

jest wyraźnie ograniczony przez wydajność dysku.

Czas wyszukiwania jest długi, ponieważ gdy używasz mmapdo, nie ładuje zawartości tablicy do pamięci podczas wywoływania loadmetody. Dane są ładowane z opóźnieniem, gdy potrzebne są określone dane. Dzieje się to podczas wyszukiwania w Twoim przypadku. Ale drugie wyszukiwanie nie będzie tak powolne.

Jest to fajna cecha, mmapgdy masz dużą tablicę, nie musisz ładować całych danych do pamięci.

Aby rozwiązać problem, użyj joblib , możesz zrzucić dowolny obiekt, używając joblib.dumpnawet dwóch lub więcej numpy arrays, patrz przykład

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