Comment stocker une trame de données à l'aide de Pandas

À l'heure actuelle, CSVj'importe un fichier assez volumineux à chaque fois que j'exécute le script. Existe-t-il une bonne solution pour garder cette trame de données disponible en permanence entre les exécutions, donc je n'ai pas à passer tout ce temps à attendre l'exécution du script?

Le moyen le plus simple est de le décaper en utilisant to_pickle:

df.to_pickle(file_name)  # where to save it, usually as a .pkl

Ensuite, vous pouvez le recharger en utilisant:

df = pd.read_pickle(file_name)

Remarque: avant 0.11.1 saveet loadétaient le seul moyen de le faire (ils sont désormais obsolètes en faveur de to_pickleet read_picklerespectivement).

Un autre choix populaire consiste à utiliser HDF5 ( pytables ) qui offre des temps d'accès très rapides pour les grands ensembles de données:

store = HDFStore('store.h5')

store['df'] = df  # save it
store['df']  # load it

Des stratégies plus avancées sont discutées dans le livre de cuisine .

Depuis 0.13, il y a aussi msgpack qui peut être meilleur pour l'interopérabilité, comme une alternative plus rapide à JSON, ou si vous avez des données objet / texte python (voir cette question ).

Bien qu'il y ait déjà quelques réponses, j'ai trouvé une belle comparaison dans laquelle ils ont essayé plusieurs façons de sérialiser les Pandas DataFrames: Stocker efficacement les Pandas DataFrames .

Ils comparent:

• cornichon: format de données ASCII d'origine
• cPickle, une bibliothèque C
• pickle-p2: utilise le nouveau format binaire
• json: bibliothèque jl standardlib
• json-no-index: comme json, mais sans index
• msgpack: alternative JSON binaire
• CSV
• hdfstore: format de stockage HDF5

Dans leur expérience, ils ont sérialisé un DataFrame de 1 000 000 lignes avec les deux colonnes testées séparément: l'une avec des données texte, l'autre avec des nombres. Leur avertissement dit:

Vous ne devez pas croire que ce qui suit se généralise à vos données. Vous devriez regarder vos propres données et exécuter vous-même des benchmarks

Le code source du test auquel ils se réfèrent est disponible en ligne . Comme ce code ne fonctionnait pas directement, j'ai apporté quelques modifications mineures, que vous pouvez obtenir ici: serialize.py, j'ai obtenu les résultats suivants:

Ils mentionnent également qu'avec la conversion des données textuelles en données catégorielles , la sérialisation est beaucoup plus rapide. Dans leur test environ 10 fois plus rapide (voir aussi le code de test).

Edit : Les temps plus élevés pour le cornichon que le CSV peuvent être expliqués par le format de données utilisé. Par défaut, pickleutilise une représentation ASCII imprimable, qui génère des ensembles de données plus volumineux. Cependant, comme le montre le graphique, le cornichon utilisant le nouveau format de données binaires (version 2, pickle-p2) a des temps de chargement beaucoup plus faibles.

Quelques autres références:

• Dans la question la bibliothèque Python la plus rapide pour lire un fichier CSV, il y a une réponse très détaillée qui compare différentes bibliothèques pour lire des fichiers csv avec un benchmark. Le résultat est que la lecture des fichiers csv numpy.fromfileest la plus rapide.
• Un autre test de sérialisation montre que msgpack , ujson et cPickle sont les plus rapides en sérialisation.

Si je comprends bien, vous utilisez déjà, pandas.read_csv()mais souhaitez accélérer le processus de développement afin que vous n'ayez pas à charger le fichier à chaque fois que vous modifiez votre script, n'est-ce pas? J'ai quelques recommandations:

1. vous pouvez charger uniquement une partie du fichier CSV en utilisant pandas.read_csv(..., nrows=1000)uniquement le bit supérieur de la table pendant le développement

2. utilisez ipython pour une session interactive, de telle sorte que vous gardiez la table pandas en mémoire lorsque vous éditez et rechargez votre script.

3. convertir le csv en une table HDF5

4. utilisation mise à jourDataFrame.to_feather() et pd.read_feather()pour stocker des données dans le format binaire de plumes compatible R qui est super rapide (entre mes mains, légèrement plus rapide que pandas.to_pickle()sur les données numériques et beaucoup plus rapide sur les données de chaîne).

Vous pourriez également être intéressé par cette réponse sur stackoverflow.

Pickle fonctionne bien!

import pandas as pd
df.to_pickle('123.pkl')    #to save the dataframe, df to 123.pkl
df1 = pd.read_pickle('123.pkl') #to load 123.pkl back to the dataframe df

Vous pouvez utiliser un fichier au format plume. C'est extrêmement rapide.

df.to_feather('filename.ft')

Pandas DataFrames ont la to_picklefonction qui est utile pour enregistrer un DataFrame:

import pandas as pd

a = pd.DataFrame({'A':[0,1,0,1,0],'B':[True, True, False, False, False]})
print a
#    A      B
# 0  0   True
# 1  1   True
# 2  0  False
# 3  1  False
# 4  0  False

a.to_pickle('my_file.pkl')

b = pd.read_pickle('my_file.pkl')
print b
#    A      B
# 0  0   True
# 1  1   True
# 2  0  False
# 3  1  False
# 4  0  False

Comme déjà mentionné, il existe différentes options et formats de fichiers ( HDF5 , JSON , CSV , parquet , SQL ) pour stocker une trame de données. Cependant, picklen'est pas un citoyen de première classe (selon votre configuration), car:

1. pickleest un risque potentiel pour la sécurité. Former la documentation Python pour cornichon :

Avertissement Le picklemodule n'est pas protégé contre les données erronées ou malveillantes. Ne décompactez jamais les données reçues d'une source non fiable ou non authentifiée.

2. pickleest lent. Trouvez ici et ici des repères.

Selon votre configuration / utilisation, les deux limitations ne s'appliquent pas, mais je ne recommanderais pas picklela persistance par défaut pour les trames de données pandas.

Les formats de fichiers Numpy sont assez rapides pour les données numériques

Je préfère utiliser les fichiers numpy car ils sont rapides et faciles à utiliser. Voici un point de référence simple pour enregistrer et charger une trame de données avec 1 colonne de 1 million de points.

import numpy as np
import pandas as pd

num_dict = {'voltage': np.random.rand(1000000)}
num_df = pd.DataFrame(num_dict)

en utilisant la %%timeitfonction magique d'ipython

%%timeit
with open('num.npy', 'wb') as np_file:
    np.save(np_file, num_df)

la sortie est

100 loops, best of 3: 5.97 ms per loop

pour charger les données dans une trame de données

%%timeit
with open('num.npy', 'rb') as np_file:
    data = np.load(np_file)

data_df = pd.DataFrame(data)

la sortie est

100 loops, best of 3: 5.12 ms per loop

PAS MAL!

LES INCONVÉNIENTS

Il y a un problème si vous enregistrez le fichier numpy en utilisant python 2, puis essayez d'ouvrir en utilisant python 3 (ou vice versa).

https://docs.python.org/3/library/pickle.html

Les formats du protocole pickle:

La version 0 du protocole est le protocole «lisible par l'homme» d'origine et est rétrocompatible avec les versions antérieures de Python.

Le protocole version 1 est un ancien format binaire qui est également compatible avec les versions antérieures de Python.

La version 2 du protocole a été introduite dans Python 2.3. Il fournit un décapage beaucoup plus efficace des classes de nouveau style. Reportez-vous à PEP 307 pour plus d'informations sur les améliorations apportées par le protocole 2.

La version 3 du protocole a été ajoutée dans Python 3.0. Il prend explicitement en charge les objets octets et ne peut pas être décroché par Python 2.x. Il s'agit du protocole par défaut et du protocole recommandé lorsque la compatibilité avec d'autres versions de Python 3 est requise.

La version 4 du protocole a été ajoutée dans Python 3.4. Il ajoute la prise en charge des très grands objets, le décapage de plus de types d'objets et certaines optimisations de format de données. Reportez-vous à PEP 3154 pour plus d'informations sur les améliorations apportées par le protocole 4.

compatibilité pyarrow entre les versions

Le mouvement global a été vers pyarrow / plume (avertissements de dépréciation de pandas / msgpack). Cependant, j'ai un défi avec pyarrow avec transitoire dans les spécifications Les données sérialisées avec pyarrow 0.15.1 ne peuvent pas être désérialisées avec 0.16.0 ARROW-7961 . J'utilise la sérialisation pour utiliser redis, je dois donc utiliser un encodage binaire.

J'ai retesté diverses options (en utilisant le cahier jupyter)

import sys, pickle, zlib, warnings, io
class foocls:
    def pyarrow(out): return pa.serialize(out).to_buffer().to_pybytes()
    def msgpack(out): return out.to_msgpack()
    def pickle(out): return pickle.dumps(out)
    def feather(out): return out.to_feather(io.BytesIO())
    def parquet(out): return out.to_parquet(io.BytesIO())

warnings.filterwarnings("ignore")
for c in foocls.__dict__.values():
    sbreak = True
    try:
        c(out)
        print(c.__name__, "before serialization", sys.getsizeof(out))
        print(c.__name__, sys.getsizeof(c(out)))
        %timeit -n 50 c(out)
        print(c.__name__, "zlib", sys.getsizeof(zlib.compress(c(out))))
        %timeit -n 50 zlib.compress(c(out))
    except TypeError as e:
        if "not callable" in str(e): sbreak = False
        else: raise
    except (ValueError) as e: print(c.__name__, "ERROR", e)
    finally: 
        if sbreak: print("=+=" * 30)        
warnings.filterwarnings("default")

Avec les résultats suivants pour ma trame de données (dans la outvariable jupyter)

pyarrow before serialization 533366
pyarrow 120805
1.03 ms ± 43.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
pyarrow zlib 20517
2.78 ms ± 81.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=
msgpack before serialization 533366
msgpack 109039
1.74 ms ± 72.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
msgpack zlib 16639
3.05 ms ± 71.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=
pickle before serialization 533366
pickle 142121
733 µs ± 38.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
pickle zlib 29477
3.81 ms ± 60.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=
feather ERROR feather does not support serializing a non-default index for the index; you can .reset_index() to make the index into column(s)
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=
parquet ERROR Nested column branch had multiple children: struct<x: double, y: double>
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=

la plume et le parquet ne fonctionnent pas pour mon bloc de données. Je vais continuer à utiliser pyarrow. Cependant je compléterai avec du cornichon (pas de compression). Lors de l'écriture dans le cache, stockez les formulaires sérialisés pyarrow et pickle. Lors de la lecture à partir du cache de secours pour décaper si la désérialisation pyarrow échoue.

Le format dépend de votre cas d'utilisation

• Enregistrez DataFrame entre les sessions de bloc-notes - plume , si vous avez l'habitude de décapage - également ok.
• Enregistrez DataFrame dans la plus petite taille de fichier possible - parquet ou pickle.gz (vérifiez ce qui est le mieux pour vos données)
• Enregistrer un très gros DataFrame (plus de 10 millions de lignes) - hdf
• Être capable de lire les données sur une autre plate-forme (pas Python) qui ne prend pas en charge d'autres formats - csv , csv.gz , vérifiez si le parquet est pris en charge
• Être capable de réviser avec vos yeux / en utilisant Excel / Google Sheets / Git diff - CSV
• Enregistrer un DataFrame qui prend presque toute la RAM - CSV

La comparaison des formats de fichiers pandas est dans cette vidéo .