Comment estimer la quantité de mémoire dont un DataFrame Pandas aura besoin?

Je me suis demandé ... Si je lis, disons, un fichier csv de 400 Mo dans un dataframe pandas (en utilisant read_csv ou read_table), y a-t-il un moyen d'estimer la quantité de mémoire dont il aura besoin? J'essaie simplement d'avoir une meilleure idée des trames de données et de la mémoire ...

df.memory_usage() renverra combien chaque colonne occupe:

>>> df.memory_usage()

Row_ID            20906600
Household_ID      20906600
Vehicle           20906600
Calendar_Year     20906600
Model_Year        20906600
...

Pour inclure des index, passez index=True.

Donc, pour obtenir la consommation globale de mémoire:

>>> df.memory_usage(index=True).sum()
731731000

En outre, le passage deep=Truepermettra un rapport d'utilisation de la mémoire plus précis, qui rend compte de l'utilisation complète des objets contenus.

Cela est dû au fait que l'utilisation de la mémoire n'inclut pas la mémoire consommée par des éléments qui ne sont pas des composants du tableau if deep=False(cas par défaut).

Voici une comparaison des différentes méthodes - sys.getsizeof(df)c'est le plus simple.

Pour cet exemple, dfest un dataframe avec 814 lignes, 11 colonnes (2 pouces, 9 objets) - lu à partir d'un fichier de formes de 427 Ko

sys.getsizeof (df)

>>> import sys
>>> sys.getsizeof (df)
(donne les résultats en octets)
462456

df.memory_usage ()

>>> df.memory_usage ()
...
(répertorie chaque colonne à 8 octets / ligne)

>>> df.memory_usage (). sum ()
71712
(environ lignes * cols * 8 octets)

>>> df.memory_usage (deep = True)
(répertorie l'utilisation complète de la mémoire de chaque colonne)

>>> df.memory_usage (deep = True) .sum ()
(donne les résultats en octets)
462432

df.info ()

Imprime les informations de la trame de données sur stdout. Techniquement, ce sont des kibioctets (Kio), pas des kilo-octets - comme le dit la docstring, "l'utilisation de la mémoire est indiquée en unités lisibles par l'homme (représentation en base 2)." Donc, obtenir des octets serait multiplié par 1024, par exemple 451,6 Kio = 462 438 octets.

>>> df.info ()
...
utilisation de la mémoire: 70,0+ Ko

>>> df.info (memory_usage = 'profond')
...
utilisation de la mémoire: 451,6 Ko

J'ai pensé que j'apporterais plus de données à la discussion.

J'ai effectué une série de tests sur ce problème.

En utilisant le resourcepackage python , j'ai obtenu l'utilisation de la mémoire de mon processus.

Et en écrivant le csv dans un StringIOtampon, je pourrais facilement en mesurer la taille en octets.

J'ai mené deux expériences, chacune créant 20 dataframes de tailles croissantes entre 10 000 lignes et 1 000 000 lignes. Les deux ayant 10 colonnes.

Dans la première expérience, j'ai utilisé uniquement des flottants dans mon ensemble de données.

C'est ainsi que la mémoire a augmenté par rapport au fichier csv en fonction du nombre de lignes. (Taille en mégaoctets)

La deuxième expérience, j'ai eu la même approche, mais les données de l'ensemble de données ne consistaient que de courtes chaînes.

Il semble que la relation entre la taille du csv et la taille de la trame de données peut varier beaucoup, mais la taille en mémoire sera toujours plus grande d'un facteur 2-3 (pour les tailles de trame de cette expérience)

J'aimerais compléter cette réponse avec plus d'expériences, veuillez commenter si vous voulez que j'essaye quelque chose de spécial.

Vous devez le faire à l'envers.

In [4]: DataFrame(randn(1000000,20)).to_csv('test.csv')

In [5]: !ls -ltr test.csv
-rw-rw-r-- 1 users 399508276 Aug  6 16:55 test.csv

Techniquement, la mémoire est à ce sujet (qui comprend les index)

In [16]: df.values.nbytes + df.index.nbytes + df.columns.nbytes
Out[16]: 168000160

Donc 168 Mo en mémoire avec un fichier de 400 Mo, 1M lignes de 20 colonnes flottantes

DataFrame(randn(1000000,20)).to_hdf('test.h5','df')

!ls -ltr test.h5
-rw-rw-r-- 1 users 168073944 Aug  6 16:57 test.h5

BEAUCOUP plus compact lorsqu'il est écrit sous forme de fichier binaire HDF5

In [12]: DataFrame(randn(1000000,20)).to_hdf('test.h5','df',complevel=9,complib='blosc')

In [13]: !ls -ltr test.h5
-rw-rw-r-- 1 users 154727012 Aug  6 16:58 test.h5

Les données étaient aléatoires, donc la compression n'aide pas trop

Si vous connaissez les dtypes de votre tableau, vous pouvez directement calculer le nombre d'octets qu'il faudra pour stocker vos données + certains pour les objets Python eux-mêmes. Un attribut utile des numpytableaux est nbytes. Vous pouvez obtenir le nombre d'octets des tableaux d'un pandas DataFrameen faisant

nbytes = sum(block.values.nbytes for block in df.blocks.values())

objectLes tableaux dtype stockent 8 octets par objet (les tableaux d'objet dtype stockent un pointeur vers un opaque PyObject), donc si vous avez des chaînes dans votre csv, vous devez prendre en compte ce read_csvqui les transformera en objecttableaux dtype et ajuster vos calculs en conséquence.

ÉDITER:

Consultez la numpypage des types scalaires pour plus de détails sur le object dtype. Comme seule une référence est stockée, vous devez également prendre en compte la taille de l'objet dans le tableau. Comme le dit cette page, les tableaux d'objets sont quelque peu similaires aux listobjets Python .

Oui il y a. Pandas stockera vos données dans des ndarraystructures numpy à 2 dimensions en les regroupant par dtypes. ndarrayest fondamentalement un tableau de données C brut avec un petit en-tête. Vous pouvez donc estimer sa taille simplement en multipliant la taille de celui dtypequ'il contient par les dimensions du tableau.

Par exemple: si vous avez 1000 lignes avec 2 np.int32et 5 np.float64colonnes, votre DataFrame aura un np.int32tableau 2x1000 et un 5x1000np.float64 tableau qui est:

4 octets * 2 * 1000 + 8 octets * 5 * 1000 = 48000 octets

Je crois que cela donne la taille en mémoire de tout objet en python. Les éléments internes doivent être vérifiés en ce qui concerne les pandas et numpy

>>> import sys
#assuming the dataframe to be df 
>>> sys.getsizeof(df) 
59542497