Tableau NumPy est pas la sérialisation JSON

Après la création d'un tableau NumPy, et l'enregistrer en tant que Django variable de contexte, je reçois l'erreur suivante lors du chargement de la page web:

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

Qu'est-ce que cela signifie?

Cela signifie que quelque part, quelque chose est en train d'essayer de vider un tableau numpy à l'aide de la json module. Mais numpy.ndarray n'est pas un type qui json sait comment la gérer. Vous devrez écrire votre propre sérialiseur, ou (plus simplement) vient de passer list(your_array) à ce qui est écrit au format json.
Note list(your_array) ne fonctionne pas toujours comme il le renvoie numpy entiers, non pas des entiers. Utilisation your_array.to_list() à la place.
une remarque à propos de @ashishsingal commentaire, il convient de your_array.tolist(), pas to_list().

OriginalL'auteur Karnivaurus | 2014-10-30

201

J'ai régulièrement des "jsonify" np.les tableaux de. Essayez d'utiliser le ".tolist ()", le moyen de tableaux premier, comme ceci:
```
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
```
Pour "unjsonify" le tableau utilisation:
```
obj_text = codecs.open(file_path, 'r', encoding='utf-8').read()
b_new = json.loads(obj_text)
a_new = np.array(b_new)
```
Pourquoi ne peut-il seulement être stockée comme une liste de listes?
Je ne sais pas, mais j'attends de np.tableau des types de métadonnées qui ne rentre pas dans le json (par exemple, spécifier le type de données de chaque entrée de type float)
J'ai essayé votre méthode, mais il semble que le programme coincé à tolist().
Vous ne savez pas comment vous aider pour l'info. S'il vous plaît essayer à fait sûr a est un tableau numpy. Puis a.tolist() est juste la méthode qui le transforme dans une liste avec la même structure.
J'ai trouvé la raison en est que tolist() prend une énorme quantité de données est importante.

OriginalL'auteur travelingbones

119

Magasin de JSON un numpy.ndarray ou tout imbriqué liste de composition.

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)

Sera de sortie:

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

De restaurer à partir de JSON:

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

Sera de sortie:

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

Cela devrait être plus haut sur le plateau, c'est le généralisées et correctement captée moyen de le faire. Merci!
Est-il un moyen simple d'obtenir la ndarray de retour à partir de la liste ?
vous êtes à la recherche pour numpy.asarray()?
Ce doit être la accepté de répondre, beaucoup plus propre façon de faire les choses.
C'EST la réponse. Excellent travail

OriginalL'auteur karlB

32

Vous pouvez utiliser Les Pandas:
```
import pandas as pd
pd.Series(your_array).to_json(orient='values')
```
Super! Et je pense que pour la 2D np.tableau il sera quelque chose comme pd.DataFrame(your_array).to_json('data.json', orient='split').
Quelles sont les données? Vous devriez peut-être poster une question de votre propre?

OriginalL'auteur John Zwinck

J'ai trouvé la meilleure solution, si vous avez imbriqué des tableaux numpy dans un dictionnaire:

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)

Grâce à ce mec.

Merci pour la réponse utile! J'ai écrit les attributs d'un fichier json, mais je suis maintenant de la difficulté de la lecture les paramètres de la Régression Logistique. Est-il un "décodeur" pour cela a sauvé fichier json?
Bien sûr, pour lire le json le dos, vous pouvez utiliser ceci: with open(path, 'r') as f: data = json.load(f) , qui retourne un dictionnaire avec vos données.
C'est à la lecture de la json fichier, puis pour désérialiser elle est sortie, vous pouvez utiliser ceci: data = json.loads(data)

OriginalL'auteur tsveti_iko

8

Beaucoup d'autres numpy encodeurs semblent un peu trop verbeux.

vérifier si l'objet si le module numpy, si donc soit utiliser ndarray.tolist pour un ndarray ou de l'utilisation .item pour toute autre numpy type spécifique.

Utiliser le json.dumps default kwarg:

valeur par défaut doit être une fonction qui est appelée pour les objets qui ne peuvent autrement être sérialisé.
```
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)
```
OriginalL'auteur moshevi
4

Ce n'est pas pris en charge par défaut, mais vous pouvez le faire fonctionner assez facilement! Il y a plusieurs choses que vous aurez envie de coder si vous voulez exactement les mêmes données:
- Les données lui-même, que vous pouvez obtenir avec obj.tolist() @travelingbones mentionné. Parfois, cela peut être assez bon.
- Le type de données. J'ai l'impression que c'est très important dans certains cas.
- La dimension (pas nécessairement 2D), qui peuvent être dérivés à partir de ci-dessus si l'on suppose que l'entrée est en effet toujours un 'rectangulaire' grille.
- La mémoire de commande (de la ligne ou de la colonne principale). Ce n'est pas souvent question, mais parfois c'est le cas (par exemple, performance), alors pourquoi ne pas tout sauver?
En outre, votre tableau numpy pourrait le cadre de votre structure de données, par exemple, vous avez une liste avec des matrices à l'intérieur. Pour que vous pourriez utiliser un codeur qui fait de la ci-dessus.

Cela devrait être suffisant pour mettre en œuvre une solution. Ou vous pourriez utiliser json-astuces qui est précisément ce que fait (et prend en charge divers autres types) (avertissement: je l'ai fait).
```
pip install json-tricks
```
Puis
```
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))
```
OriginalL'auteur Mark

J'ai eu un problème similaire avec un imbriquée dictionnaire avec certains numpy.ndarrays.

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

OriginalL'auteur JLT

Vous pouvez également utiliser default argument par exemple:

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

json.dump(data, default=myconverter)

OriginalL'auteur steco

1

Aussi, de très intéressants renseignements supplémentaires sur les listes vs tableaux en Python ~> Liste Python vs. Tableau - quand les utiliser?

Il est à noter qu'une fois que j'convertir mes tableaux dans une liste avant de l'enregistrer dans un fichier JSON, dans mon déploiement droit maintenant de toute façon, j'ai lu une fois que le fichier JSON pour les utiliser plus tard, je peux continuer à l'utiliser dans une liste (par opposition à la conversion de celle-ci à un tableau).

ET en fait ressemble plus belle (à mon avis) sur l'écran sous forme de liste (séparés par des virgules) par rapport à un tableau (non-séparation par virgule) de cette façon.

À l'aide de @travelingbones .tolist() la méthode ci-dessus, j'ai été de les utiliser en tant que tel (à attraper quelques erreurs que j'ai trouvé trop):

ENREGISTRER DICTIONNAIRE
```
def writeDict(values, name):
    writeName = DIR+name+'.json'
    with open(writeName, "w") as outfile:
        json.dump(values, outfile)
```
LIRE DICTIONNAIRE
```
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')
```
Espérons que cette aide!

OriginalL'auteur ntk4

Ici est une mise en œuvre qui fonctionnent pour moi et supprimé tous les nans (en supposant que ce sont de simple objet (liste 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

OriginalL'auteur Roei Bahumi

1

C'est une réponse différente, mais cela peut vous aider à aider les gens qui essaient de sauvegarder les données et de les relire.

Il est hickle qui est plus rapide que pickle et plus facile.

J'ai essayé d'enregistrer et de lire dans la saumure dump mais à la lecture il y avait beaucoup de problèmes et de gaspillage d'une heure et n'a pas encore trouvé de solution même si j'ai eu à travailler sur mes propres données pour créer un chat bot.

vec_x et vec_y sont des tableaux numpy:
```
data=[vec_x,vec_y]
hkl.dump( data, 'new_data_file.hkl' )
```
Alors que vous venez de lire et effectuer les opérations:
```
data2 = hkl.load( 'new_data_file.hkl' )
```
OriginalL'auteur KS HARSHA

Peut faire simple boucle for avec la vérification de types:

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

OriginalL'auteur Robert GRZELKA

1

TypeError: array([[0.46872085, 0.67374235, 1.0218339 , 0.13210179, 0.5440686 , 0.9140083 , 0.58720225, 0.2199381 ]], dtype=float32) n'est pas JSON serializable

L'erreur ci-dessus a été jeté quand j'ai essayé de passer de la liste de données de modèle.predict() quand j'attendais la réponse au format 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)
```
Mais heureusement trouvé l'astuce pour résoudre l'erreur a été de jeter
La sérialisation des objets est applicable seulement pour la conversion suivante
La cartographie doit être dans la façon suivante
objet - dict
tableau - liste
string - chaîne
entier - entier

Si vous faites défiler pour voir le numéro de la ligne 10
prédiction = loaded_model.prévoir(d) où cette ligne de code a été la génération de la sortie
de type array type de données , lorsque vous essayez de convertir le tableau en format json ce n'est pas possible

J'ai enfin trouvé la solution obtenue par conversion de sortie de la liste type par
lignes de code suivantes

prédiction = loaded_model.prévoir(d)

listtype = prédiction.tolist()
retour jsonify(listtype)

Bhoom! a finalement obtenu les résultats attendus,

OriginalL'auteur Poornima Subramani Naidu

Vous devez vous connecter pour publier un commentaire.