Comment puis-je sérialiser un tableau numpy, tout en préservant la matrice de dimensions?

pickle.décharges ou numpy.enregistrer encoder toutes les informations nécessaires pour reconstruire l'arbitraire d'un tableau NumPy, même en présence de l'endianness questions, non contigus des tableaux, ou bizarre tuple dtypes. Endianness questions sont probablement le plus important; vous ne voulez pas array([1]) soudainement devenir array([16777216]) parce que vous avez chargé votre tableau sur un big-endian machine. pickle est probablement le plus pratique, mais save a ses propres avantages, compte tenu de la npy format de justification.

La pickle option:

import pickle
a = # some NumPy array
serialized = pickle.dumps(a, protocol=0) # protocol 0 is printable ASCII
deserialized_a = pickle.loads(serialized)

numpy.save utilise un format binaire, et il doit écrire dans un fichier, mais vous pouvez vous déplacer qu'avec StringIO:

a = # any NumPy array
memfile = StringIO.StringIO()
numpy.save(memfile, a)
memfile.seek(0)
serialized = json.dumps(memfile.read().decode('latin-1'))
# latin-1 maps byte n to unicode code point n

Et désérialiser:

memfile = StringIO.StringIO()
memfile.write(json.loads(serialized).encode('latin-1'))
memfile.seek(0)
a = numpy.load(memfile)

J'ai trouvé le code dans Msgpack-numpy utile.
https://github.com/lebedov/msgpack-numpy/blob/master/msgpack_numpy.py

J'ai modifié le sérialisés dict légèrement et ajout de l'encodage base64 pour réduire la sérialisés taille.

À l'aide de la même interface que le json (offrant charge(s),dump(s)), vous pouvez fournir une baisse-dans le remplacement pour la sérialisation json.

Cette même logique peut être étendu à l'ajout automatique de la non-trivial de la sérialisation, tels que les objets datetime.

MODIFIER
J'ai écrit un générique, modulaire, analyseur qui fait cela, et plus encore.
https://github.com/someones/jaweson

Mon code est comme suit:

np_json.py

from json import *
import json
import numpy as np
import base64
def to_json(obj):
if isinstance(obj, (np.ndarray, np.generic)):
if isinstance(obj, np.ndarray):
return {
'__ndarray__': base64.b64encode(obj.tostring()),
'dtype': obj.dtype.str,
'shape': obj.shape,
}
elif isinstance(obj, (np.bool_, np.number)):
return {
'__npgeneric__': base64.b64encode(obj.tostring()),
'dtype': obj.dtype.str,
}
if isinstance(obj, set):
return {'__set__': list(obj)}
if isinstance(obj, tuple):
return {'__tuple__': list(obj)}
if isinstance(obj, complex):
return {'__complex__': obj.__repr__()}
# Let the base class default method raise the TypeError
raise TypeError('Unable to serialise object of type {}'.format(type(obj)))
def from_json(obj):
# check for numpy
if isinstance(obj, dict):
if '__ndarray__' in obj:
return np.fromstring(
base64.b64decode(obj['__ndarray__']),
dtype=np.dtype(obj['dtype'])
).reshape(obj['shape'])
if '__npgeneric__' in obj:
return np.fromstring(
base64.b64decode(obj['__npgeneric__']),
dtype=np.dtype(obj['dtype'])
)[0]
if '__set__' in obj:
return set(obj['__set__'])
if '__tuple__' in obj:
return tuple(obj['__tuple__'])
if '__complex__' in obj:
return complex(obj['__complex__'])
return obj
# over-write the load(s)/dump(s) functions
def load(*args, **kwargs):
kwargs['object_hook'] = from_json
return json.load(*args, **kwargs)
def loads(*args, **kwargs):
kwargs['object_hook'] = from_json
return json.loads(*args, **kwargs)
def dump(*args, **kwargs):
kwargs['default'] = to_json
return json.dump(*args, **kwargs)
def dumps(*args, **kwargs):
kwargs['default'] = to_json
return json.dumps(*args, **kwargs)

Vous devriez être en mesure de procéder de la façon suivante:

import numpy as np
import np_json as json
np_data = np.zeros((10,10), dtype=np.float32)
new_data = json.loads(json.dumps(np_data))
assert (np_data == new_data).all()

Si elle doit être lisible par l'homme et vous savez que c'est un tableau numpy:

import numpy as np; 
import json;
a = np.random.normal(size=(50,120,150))
a_reconstructed = np.asarray(json.loads(json.dumps(a.tolist())))
print np.allclose(a,a_reconstructed)
print (a==a_reconstructed).all()

Peut-être pas le plus efficace à mesure que le tableau des tailles de grandir, mais travaille pour les plus petits tableaux.

Essayez d'utiliser numpy.array_repr ou numpy.array_str.