Come stimare la quantità di memoria necessaria a un DataFrame di Pandas?

Mi chiedevo ... Se sto leggendo, ad esempio, un file csv da 400 MB in un dataframe pandas (usando read_csv o read_table), c'è un modo per indovinare di quanta memoria avrà bisogno? Sto solo cercando di avere un'idea migliore dei frame di dati e della memoria ...

df.memory_usage() restituirà quanto occupa ciascuna colonna:

>>> df.memory_usage()

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

Per includere gli indici, passa index=True.

Quindi, per ottenere il consumo di memoria complessivo:

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

Inoltre, il passaggio deep=Trueconsentirà un rapporto sull'utilizzo della memoria più accurato, che tiene conto del pieno utilizzo degli oggetti contenuti.

Questo perché l'utilizzo della memoria non include la memoria consumata da elementi che non sono componenti dell'array if deep=False(caso predefinito).

Ecco un confronto tra i diversi metodi: sys.getsizeof(df)è il più semplice.

Per questo esempio, dfè un dataframe con 814 righe, 11 colonne (2 int, 9 oggetti) - letto da uno shapefile da 427kb

sys.getsizeof (df)

>>> import sys
>>> sys.getsizeof (df)
(fornisce risultati in byte)
462.456

df.memory_usage ()

>>> df.memory_usage ()
...
(elenca ogni colonna a 8 byte / riga)

>>> df.memory_usage (). sum ()
71712
(all'incirca righe * colonne * 8 byte)

>>> df.memory_usage (deep = True)
(elenca l'utilizzo completo della memoria di ciascuna colonna)

>>> df.memory_usage (deep = True) .sum ()
(fornisce risultati in byte)
462.432

df.info ()

Stampa le informazioni del dataframe su stdout. Tecnicamente questi sono kibibyte (KiB), non kilobyte - come dice la docstring, "L'utilizzo della memoria è mostrato in unità leggibili dall'uomo (rappresentazione in base 2)". Quindi per ottenere byte si moltiplicherebbe per 1024, ad esempio 451,6 KiB = 462,438 byte.

>>> df.info ()
...
utilizzo della memoria: 70.0+ KB

>>> df.info (memory_usage = 'deep')
...
utilizzo della memoria: 451,6 KB

Ho pensato di portare qualche dato in più alla discussione.

Ho eseguito una serie di test su questo problema.

Utilizzando il resourcepacchetto python ho ottenuto l'utilizzo della memoria del mio processo.

E scrivendo il csv in un StringIObuffer, potrei facilmente misurarne la dimensione in byte.

Ho eseguito due esperimenti, ciascuno creando 20 frame di dati di dimensioni crescenti tra 10.000 e 1.000.000 di linee. Entrambi hanno 10 colonne.

Nel primo esperimento ho usato solo float nel mio set di dati.

In questo modo la memoria è aumentata rispetto al file csv in funzione del numero di righe. (Dimensioni in megabyte)

Il secondo esperimento ho avuto lo stesso approccio, ma i dati nel set di dati consistevano solo di brevi stringhe.

Sembra che la relazione tra la dimensione del csv e la dimensione del dataframe possa variare molto, ma la dimensione in memoria sarà sempre maggiore di un fattore 2-3 (per le dimensioni dei frame in questo esperimento)

Mi piacerebbe completare questa risposta con più esperimenti, per favore commenta se vuoi che provi qualcosa di speciale.

Devi farlo al contrario.

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

Tecnicamente la memoria riguarda questo (che include gli indici)

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

Quindi 168 MB di memoria con un file da 400 MB, 1 milione di righe di 20 colonne float

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

MOLTO più compatto se scritto come file binario 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

I dati erano casuali, quindi la compressione non aiuta molto

Se conosci gli dtypes del tuo array, puoi calcolare direttamente il numero di byte che ci vorrà per memorizzare i tuoi dati + alcuni per gli oggetti Python stessi. Un attributo utile degli numpyarray è nbytes. Puoi ottenere il numero di byte dagli array in un panda DataFramefacendo

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

objectGli array dtype memorizzano 8 byte per oggetto (gli array dtype di oggetti memorizzano un puntatore a un opaco PyObject), quindi se hai stringhe nel tuo CSV devi tener conto che read_csvle trasformerà in objectarray dtype e aggiusterai i tuoi calcoli di conseguenza.

MODIFICARE:

Vedi la numpypagina dei tipi scalari per maggiori dettagli su object dtype. Poiché viene memorizzato solo un riferimento, è necessario tenere in considerazione anche la dimensione dell'oggetto nell'array. Come dice quella pagina, gli array di oggetti sono in qualche modo simili agli listoggetti Python .

Si C'è. I panda memorizzeranno i tuoi dati in ndarraystrutture numpy bidimensionali raggruppandoli per dtypes. ndarrayè fondamentalmente un array C grezzo di dati con una piccola intestazione. Quindi puoi stimare la sua dimensione semplicemente moltiplicando la dimensione del dtypecontenuto con le dimensioni dell'array.

Ad esempio: se hai 1000 righe con 2 np.int32e 5 np.float64colonne, il tuo DataFrame avrà un np.int32array 2x1000 e un np.float64array 5x1000 che è:

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

Questo credo che questo dia la dimensione in memoria di qualsiasi oggetto in Python. Gli interni devono essere controllati per quanto riguarda panda e numpy

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