Como estimar quanta memória um DataFrame do Pandas vai precisar?

Eu estive pensando ... Se eu estiver lendo, digamos, um arquivo csv de 400 MB em um dataframe do pandas (usando read_csv ou read_table), há alguma maneira de estimar quanta memória isso vai precisar? Só tentando ter uma ideia melhor dos frames de dados e da memória ...

df.memory_usage() retornará quanto cada coluna ocupa:

>>> df.memory_usage()

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

Para incluir índices, passe index=True.

Portanto, para obter o consumo geral de memória:

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

Além disso, a passagem deep=Truepermitirá um relatório de uso de memória mais preciso, que contabiliza o uso total dos objetos contidos.

Isso ocorre porque o uso de memória não inclui a memória consumida por elementos que não são componentes da matriz if deep=False(caso padrão).

Aqui está uma comparação dos diferentes métodos - sys.getsizeof(df)é o mais simples.

Para este exemplo, dfé um dataframe com 814 linhas, 11 colunas (2 ints, 9 objetos) - lido a partir de um shapefile de 427kb

sys.getsizeof (df)

>>> import sys
>>> sys.getsizeof (df)
(dá resultados em bytes)
462456

df.memory_usage ()

>>> df.memory_usage ()
...
(lista cada coluna em 8 bytes / linha)

>>> df.memory_usage (). sum ()
71712
(aproximadamente linhas * cols * 8 bytes)

>>> df.memory_usage (deep = True)
(lista o uso total de memória de cada coluna)

>>> df.memory_usage (deep = True) .sum ()
(dá resultados em bytes)
462432

df.info ()

Imprime informações do dataframe no stdout. Tecnicamente, são kibibytes (KiB), não kilobytes - como diz a docstring, "O uso da memória é mostrado em unidades legíveis (representação de base 2)." Portanto, obter bytes seria multiplicado por 1024, por exemplo, 451,6 KiB = 462.438 bytes.

>>> df.info ()
...
uso de memória: 70,0+ KB

>>> df.info (memory_usage = 'deep')
...
uso de memória: 451,6 KB

Pensei em trazer mais alguns dados para a discussão.

Executei uma série de testes sobre esse problema.

Usando o resourcepacote python , consegui o uso de memória do meu processo.

E escrevendo o csv em um StringIObuffer, eu poderia facilmente medir o tamanho dele em bytes.

Fiz dois experimentos, cada um criando 20 dataframes de tamanhos crescentes entre 10.000 e 1.000.000 de linhas. Ambos com 10 colunas.

No primeiro experimento, usei apenas flutuadores em meu conjunto de dados.

É assim que a memória aumentou em comparação ao arquivo csv em função do número de linhas. (Tamanho em megabytes)

No segundo experimento, tive a mesma abordagem, mas os dados no conjunto de dados consistiam em apenas sequências curtas.

Parece que a relação entre o tamanho do csv e o tamanho do dataframe pode variar bastante, mas o tamanho na memória será sempre maior por um fator de 2-3 (para os tamanhos de quadro neste experimento)

Eu adoraria completar esta resposta com mais experimentos, por favor, comente se você quiser que eu tente algo especial.

Você tem que fazer isso ao contrário.

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, a memória é sobre isso (que inclui os índices)

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

Portanto, 168 MB de memória com um arquivo de 400 MB, 1 milhão de linhas de 20 colunas flutuantes

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

MUITO mais compacto quando escrito como um arquivo HDF5 binário

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

Os dados eram aleatórios, então a compressão não ajuda muito

Se você conhece os dtypes do seu array, então pode calcular diretamente o número de bytes necessários para armazenar seus dados + alguns para os próprios objetos Python. Um atributo útil dos numpyarrays é nbytes. Você pode obter o número de bytes dos arrays em um pandas DataFramefazendo

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

objectArrays dtype armazenam 8 bytes por objeto (arrays dtype de objetos armazenam um ponteiro para um opaco PyObject), então se você tem strings em seu csv você precisa levar em consideração que read_csvirá transformá-los emobject arrays dtype e ajustar seus cálculos de acordo.

EDITAR:

Consulte a numpypágina de tipos escalares para obter mais detalhes sobre o object dtype. Visto que apenas uma referência é armazenada, você também precisa levar em consideração o tamanho do objeto no array. Como diz a página, os arrays de objetos são um tanto semelhantes aos listobjetos Python .

Sim existe. O Pandas irá armazenar seus dados em ndarrayestruturas numpy bidimensionais agrupando-os por dtypes. ndarrayé basicamente uma matriz de dados C bruta com um pequeno cabeçalho. Assim, você pode estimar seu tamanho simplesmente multiplicando o tamanho do dtypeque contém pelas dimensões da matriz.

Por exemplo: se você tiver 1000 linhas com 2 np.int32e 5 np.float64colunas, seu DataFrame terá uma np.int32matriz 2x1000 e uma np.float64matriz 5x1000 que é:

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

Isso eu acredito que dá o tamanho na memória de qualquer objeto em python. Os internos precisam ser verificados em relação aos pandas e entorpecidos

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