A matriz NumPy não é JSON serializável

Depois de criar uma matriz NumPy e salvá-la como uma variável de contexto do Django, recebo o seguinte erro ao carregar a página da web:

array([   0,  239,  479,  717,  952, 1192, 1432, 1667], dtype=int64) is not JSON serializable

O que isto significa?

Eu regularmente "jsonify" np.arrays. Tente usar o método ".tolist ()" nas matrizes primeiro, assim:

import numpy as np
import codecs, json 

a = np.arange(10).reshape(2,5) # a 2 by 5 array
b = a.tolist() # nested lists with same data, indices
file_path = "/path.json" ## your path variable
json.dump(b, codecs.open(file_path, 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=4) ### this saves the array in .json format

Para "desjsonificar" a matriz, use:

obj_text = codecs.open(file_path, 'r', encoding='utf-8').read()
b_new = json.loads(obj_text)
a_new = np.array(b_new)

Armazene como JSON um numpy.ndarray ou qualquer composição de lista aninhada.

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

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)
json_dump = json.dumps({'a': a, 'aa': [2, (2, 3, 4), a], 'bb': [2]}, cls=NumpyEncoder)
print(json_dump)

Saída:

(2, 3)
{"a": [[1, 2, 3], [4, 5, 6]], "aa": [2, [2, 3, 4], [[1, 2, 3], [4, 5, 6]]], "bb": [2]}

Para restaurar a partir do JSON:

json_load = json.loads(json_dump)
a_restored = np.asarray(json_load["a"])
print(a_restored)
print(a_restored.shape)

Saída:

[[1 2 3]
 [4 5 6]]
(2, 3)

Você pode usar o Pandas :

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

Encontrei a melhor solução se você aninhar matrizes numpy em um dicionário:

import json
import numpy as np

class NumpyEncoder(json.JSONEncoder):
    """ Special json encoder for numpy types """
    def default(self, obj):
        if isinstance(obj, np.integer):
            return int(obj)
        elif isinstance(obj, np.floating):
            return float(obj)
        elif isinstance(obj, np.ndarray):
            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)

Graças a esse cara .

Use o json.dumps defaultkwarg:

o padrão deve ser uma função que é chamada para objetos que não poderiam ser serializados.

Na defaultfunção, verifique se o objeto é do módulo numpy, se for o caso, use ndarray.tolistpara um ndarrayou use .itempara qualquer outro tipo específico de numpy.

import numpy as np

def default(obj):
    if type(obj).__module__ == np.__name__:
        if isinstance(obj, np.ndarray):
            return obj.tolist()
        else:
            return obj.item()
    raise TypeError('Unknown type:', type(obj))

dumped = json.dumps(data, default=default)

Isso não é suportado por padrão, mas você pode fazê-lo funcionar facilmente! Há várias coisas que você deseja codificar se desejar os mesmos dados exatamente de volta:

• Os dados em si, que você pode obter obj.tolist()como os @travelingbones mencionados. Às vezes isso pode ser bom o suficiente.
• O tipo de dados. Eu sinto que isso é importante em alguns casos.
• A dimensão (não necessariamente 2D), que pode ser derivada do exposto acima, se você assumir que a entrada é realmente sempre uma grade 'retangular'.
• A ordem da memória (principal da linha ou coluna). Isso geralmente não importa, mas às vezes sim (por exemplo, desempenho), por que não salvar tudo?

Além disso, sua matriz numpy pode fazer parte da sua estrutura de dados, por exemplo, você possui uma lista com algumas matrizes. Para isso, você pode usar um codificador personalizado, que basicamente faz o acima.

Isso deve ser suficiente para implementar uma solução. Ou você pode usar o json-tricks, que faz exatamente isso (e suporta vários outros tipos) (aviso: eu fiz isso).

pip install json-tricks

Então

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

Eu tive um problema semelhante com um dicionário aninhado com alguns numpy.ndarrays nele.

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

Você também pode usar o defaultargumento, por exemplo:

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

json.dump(data, default=myconverter)

Além disso, algumas informações muito interessantes ainda mais sobre listas vs. matrizes em Python ~> Lista Python vs. Matriz - quando usar?

Pode-se observar que, depois de converter minhas matrizes em uma lista antes de salvá-las em um arquivo JSON, na minha implantação agora mesmo assim, depois de ler o arquivo JSON para uso posterior, posso continuar usando-o em uma forma de lista (como em vez de convertê-lo novamente em uma matriz).

E, na verdade, parece melhor (na minha opinião) na tela como uma lista (vírgula separada) versus uma matriz (sem vírgula separada) dessa maneira.

Usando o método .tolist () de @ travelingbones acima, eu tenho usado como tal (capturando alguns erros que encontrei também):

SALVAR DICIONÁRIO

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

LEIA O DICIONÁRIO

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 isto ajude!

Aqui está uma implementação que funciona para mim e removeu todas as nans (assumindo que sejam objetos simples (lista ou 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

Essa é uma resposta diferente, mas isso pode ajudar a ajudar as pessoas que estão tentando salvar dados e depois lê-los novamente.
Há hickle que é mais rápido que pickle e mais fácil.
Tentei salvar e ler no pickle dump, mas durante a leitura houve muitos problemas e perdi uma hora e ainda não encontrei solução, embora estivesse trabalhando nos meus próprios dados para criar um bot de bate-papo.

vec_xe vec_ysão matrizes numpy:

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

Então você acabou de ler e executar as operações:

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

Pode ser simples para loop com tipos de verificação:

with open("jsondontdoit.json", 'w') as fp:
    for key in bests.keys():
        if type(bests[key]) == np.ndarray:
            bests[key] = bests[key].tolist()
            continue
        for idx in bests[key]:
            if type(bests[key][idx]) == np.ndarray:
                bests[key][idx] = bests[key][idx].tolist()
    json.dump(bests, fp)
    fp.close()

use NumpyEncoder que processará o json dump com sucesso. sem jogar - o array NumPy não é JSON serializável

import numpy as np
import json
from numpyencoder import NumpyEncoder
arr = array([   0,  239,  479,  717,  952, 1192, 1432, 1667], dtype=int64) 
json.dumps(arr,cls=NumpyEncoder)

TypeError: array ([[0.46872085, 0.67374235, 1.0218339, 0.13210179, 0.5440686, 0.9140083, 0.58720225, 0.2199381]], dtype = float32) não é serializador JSON

O erro acima mencionado foi lançado quando tentei passar a lista de dados para model.predict () quando esperava a resposta no formato json.

> 1        json_file = open('model.json','r')
> 2        loaded_model_json = json_file.read()
> 3        json_file.close()
> 4        loaded_model = model_from_json(loaded_model_json)
> 5        #load weights into new model
> 6        loaded_model.load_weights("model.h5")
> 7        loaded_model.compile(optimizer='adam', loss='mean_squared_error')
> 8        X =  [[874,12450,678,0.922500,0.113569]]
> 9        d = pd.DataFrame(X)
> 10       prediction = loaded_model.predict(d)
> 11       return jsonify(prediction)

Mas, felizmente, encontrei a dica para resolver o erro que estava lançando. A serialização dos objetos é aplicável apenas à conversão a seguir O mapeamento deve ser da seguinte maneira object - dict array - list string - string integer - integer

Se você rolar para cima para ver o número da linha 10 prediction = loaded_model.predict (d) em que essa linha de código estava gerando a saída do tipo array datatype, ao tentar converter a matriz para o formato json, não é possível

Finalmente, encontrei a solução convertendo a saída obtida para a lista de tipos seguindo as linhas de código

predição = loading_model.predict (d)
listtype = prediction.tolist () retorna jsonify (listtype)

Bhoom! finalmente obteve a saída esperada,