Matriz NumPy no es serializable JSON

class NumpyEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, np.ndarray):
            return obj.tolist()
        return json.JSONEncoder.default(self, obj)

A = np.matriz([1, 2, 3])

Print (json.vertederos({'aa': [2, (2, 3, 4), a], 'bb': [2]}, cls=NumpyEncoder))

{"aa": [2, [2, 3, 4], [1, 2, 3]], "bb": [2]}

Puedes usar Pandas :

import pandas as pd
pd.Series(your_array).to_json(orient='values')

He encontrado la mejor solución si ha anidado matrices numpy en un diccionario:

import json
import numpy as np

class NumpyEncoder(json.JSONEncoder):
    """ Special json encoder for numpy types """
    def default(self, obj):
        if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,
            np.int16, np.int32, np.int64, np.uint8,
            np.uint16, np.uint32, np.uint64)):
            return int(obj)
        elif isinstance(obj, (np.float_, np.float16, np.float32, 
            np.float64)):
            return float(obj)
        elif isinstance(obj,(np.ndarray,)): #### This is the fix
            return obj.tolist()
        return json.JSONEncoder.default(self, obj)

dumped = json.dumps(data, cls=NumpyEncoder)

with open(path, 'w') as f:
    json.dump(dumped, f)

Gracias a este tipo.

Esto no es soportado por defecto, pero puedes hacer que funcione muy fácilmente! Hay varias cosas que usted querrá codificar si desea exactamente los mismos datos de vuelta:

• Los datos en sí, que puede obtener con obj.tolist() como @travelingbones mencionado. A veces esto puede ser suficiente.
• El tipo de datos. Creo que esto es importante en algunos casos.
• La dimensión (no necesariamente 2D), que podría derivarse de lo anterior si asume que la entrada es siempre una cuadrícula rectangular.
• El orden de la memoria (fila - o columna-mayor). Esto a menudo no importa, pero a veces sí (por ejemplo, rendimiento), así que ¿por qué no guardar todo?

Además, su matriz numpy podría formar parte de su estructura de datos, por ejemplo, tiene una lista con algunas matrices dentro. Para eso se puede utilizar un codificador personalizado que básicamente hace lo anterior.

Esto debería ser suficiente para implementar una solución. O podrías usar json-tricks que hace justo esto (y soporta varios otros tipos) (descargo de responsabilidad: Lo hice).

pip install json-tricks

Entonces

data = [
    arange(0, 10, 1, dtype=int).reshape((2, 5)),
    datetime(year=2017, month=1, day=19, hour=23, minute=00, second=00),
    1 + 2j,
    Decimal(42),
    Fraction(1, 3),
    MyTestCls(s='ub', dct={'7': 7}),  # see later
    set(range(7)),
]
# Encode with metadata to preserve types when decoding
print(dumps(data))

Tuve un problema similar con un diccionario anidado con algunos numpy.ndarrays en él.

def jsonify(data):
    json_data = dict()
    for key, value in data.iteritems():
        if isinstance(value, list): # for lists
            value = [ jsonify(item) if isinstance(item, dict) else item for item in value ]
        if isinstance(value, dict): # for nested lists
            value = jsonify(value)
        if isinstance(key, int): # if key is integer: > to string
            key = str(key)
        if type(value).__module__=='numpy': # if value is numpy.*: > to python list
            value = value.tolist()
        json_data[key] = value
    return json_data

También hay información muy interesante sobre listas vs. arrays en Python ~> Lista de Python vs. Array - ¿cuándo usar?

Se podría notar que una vez que convierta mis matrices en una lista antes de guardarlas en un archivo JSON, en mi implementación ahora mismo de todos modos, una vez que lea ese archivo JSON para usarlo más tarde, puedo continuar usándolo en forma de lista (en lugar de convertirlo de nuevo a una matriz).

Y en realidad se ve mejor (en mi opinión) en la pantalla como una lista (coma separados) vs una matriz (no-separados por comas) de esta manera.

Usando @travelingbones.el método tolist () anterior, he estado usando como tal (capturando algunos errores que también he encontrado):

GUARDAR DICCIONARIO

def writeDict(values, name):
    writeName = DIR+name+'.json'
    with open(writeName, "w") as outfile:
        json.dump(values, outfile)

LEA EL DICCIONARIO

def readDict(name):
    readName = DIR+name+'.json'
    try:
        with open(readName, "r") as infile:
            dictValues = json.load(infile)
            return(dictValues)
    except IOError as e:
        print(e)
        return('None')
    except ValueError as e:
        print(e)
        return('None')

Espero que esto ayude!

Aquí hay una implementación que funciona para mí y eliminó todas las nan (asumiendo que son objetos simples (lista o dict)):

from numpy import isnan

def remove_nans(my_obj, val=None):
    if isinstance(my_obj, list):
        for i, item in enumerate(my_obj):
            if isinstance(item, list) or isinstance(item, dict):
                my_obj[i] = remove_nans(my_obj[i], val=val)

            else:
                try:
                    if isnan(item):
                        my_obj[i] = val
                except Exception:
                    pass

    elif isinstance(my_obj, dict):
        for key, item in my_obj.iteritems():
            if isinstance(item, list) or isinstance(item, dict):
                my_obj[key] = remove_nans(my_obj[key], val=val)

            else:
                try:
                    if isnan(item):
                        my_obj[key] = val
                except Exception:
                    pass

    return my_obj

Esta es una respuesta diferente, pero esto podría ayudar a ayudar a las personas que están tratando de guardar datos y luego leerlos de nuevo.
Hay hickle que es más rápido que encurtido y más fácil.
Intenté guardarlo y leerlo en pickle dump, pero mientras leía hubo muchos problemas y desperdicié una hora y aún no encontré la solución, aunque estaba trabajando en mis propios datos para crear un chat bot.

vec_x y vec_y son matrices numpy:

data=[vec_x,vec_y]
hkl.dump( data, 'new_data_file.hkl' )

Entonces usted acaba de leerlo y realizar el operaciones:

data2 = hkl.load( 'new_data_file.hkl' )

También puedes usar el argumento default por ejemplo:

def myconverter(o):
    if isinstance(o, np.float32):
        return float(o)

json.dump(data, default=myconverter)

Todos los otros codificadores numpy parecen un poco demasiado complicados. comprobar si el objeto si desde el módulo numpy si es así utilizar numpy.item, funciona para cualquier tipo específico numpy.

import numpy as np
import json

class NumpyEncoder(json.JSONEncoder):
    def default(self, obj):
        if type(obj).__module__ == np.__name__:
            return obj.item()
        return json.JSONEncoder.default(self, obj)

dumped = json.dumps(data, cls=NumpyEncoder)