¿Cómo puedo serializar una matriz numpy mientras conservo las dimensiones de la matriz?

EDIT: Como se puede leer en los comentarios de la pregunta, esta solución trata con matrices numpy "normales" (floats, ints, bools ...) y no con arrays estructurados multitipo.

Solución para serializar una matriz numpy de cualquier dimensión y tipo de datos

Por lo que sé, no se puede serializar simplemente una matriz numpy con cualquier tipo de datos y cualquier dimensión...pero puede almacenar su tipo de datos, dimensión e información en una representación de lista y luego serializarla usando JSON.

Importaciones necesarias :

import json
import base64

Para codificar se puede usar (nparray es una matriz numpy de cualquier tipo de datos y cualquier dimensionalidad):

json.dumps([str(nparray.dtype), base64.b64encode(nparray), nparray.shape])

Después de esto se obtiene un volcado JSON (cadena) de sus datos, que contiene una representación de lista de su tipo de datos y forma, así como los arrays datos/contenidos codificados en base64.

Y para decodificar esto hace el trabajo (encStr es la cadena JSON codificada, cargada desde algún lugar):

# get the encoded json dump
enc = json.loads(encStr)

# build the numpy data type
dataType = numpy.dtype(enc[0])

# decode the base64 encoded numpy array data and create a new numpy array with this data & type
dataArray = numpy.frombuffer(base64.decodestring(enc[1]), dataType)

# if the array had more than one data set it has to be reshaped
if len(enc) > 2:
     dataArray.reshape(enc[2])   # return the reshaped numpy array containing several data sets

JSON los volcados son eficientes y compatibles por muchas razones, pero solo tomar JSON conduce a resultados inesperados si desea almacenar y cargar matrices numpy de cualquier tipo y cualquier dimensión.

Esta solución almacena y carga matrices numpy independientemente del tipo o dimensión y también los restaura correctamente (tipo de datos, dimensión,...)

Probé varias soluciones hace meses y esta fue la única solución eficiente y versátil que encontré.

Encontré útil el código en Msgpack-numpy. https://github.com/lebedov/msgpack-numpy/blob/master/msgpack_numpy.py

Modifiqué ligeramente el diccionario serializado y agregué la codificación base64 para reducir el tamaño serializado.

Mediante el uso de la misma interfaz que json (proporcionando carga(s),volcado(s)), puede proporcionar un reemplazo directo para la serialización json.

Esta misma lógica se puede extender para agregar cualquier serialización automática no trivial, como datetime objeto.

EDITAR He escrito un analizador genérico modular que hace esto y más. https://github.com/someones/jaweson

Mi código es el siguiente:

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)

Usted debe ser capaz de hacer lo siguiente:

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 necesita ser legible por humanos y sabes que esto es una matriz 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()

Tal vez no sea el más eficiente a medida que los tamaños de las matrices crecen, pero funciona para matrices más pequeñas.

Msgpack tiene el mejor rendimiento de serialización: http://www.benfrederickson.com/dont-pickle-your-data /

Use msgpack-numpy. Véase https://github.com/lebedov/msgpack-numpy

Instalarlo:

pip install msgpack-numpy

Entonces:

import msgpack
import msgpack_numpy as m
import numpy as np

x = np.random.rand(5)
x_enc = msgpack.packb(x, default=m.encode)
x_rec = msgpack.unpackb(x_enc, object_hook=m.decode)

Intente traitschema https://traitschema.readthedocs.io/en/latest /

"Cree esquemas serializables y comprobados usando traits y Numpy. Un caso de uso típico implica guardar varias matrices Numpy de forma y tipo variables."

Intenta usar numpy.array_repr o numpy.array_str.