Como armazenar um quadro de dados usando o Pandas

No momento, estou importando um quadro de dados bastante grande CSVtoda vez que executo o script. Existe uma boa solução para manter esse dataframe constantemente disponível entre as execuções, para que eu não precise gastar todo esse tempo esperando a execução do script?

A maneira mais fácil é buscá- lo usando to_pickle:

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

Em seguida, você pode carregá-lo novamente usando:

df = pd.read_pickle(file_name)

Nota: antes de 0.11.1 savee loadera a única maneira de fazer isso (agora eles foram descontinuados em favor to_picklee read_picklerespectivamente).

Outra opção popular é usar o HDF5 ( pytables ), que oferece tempos de acesso muito rápidos para grandes conjuntos de dados:

store = HDFStore('store.h5')

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

Estratégias mais avançadas são discutidas no livro de receitas .

Desde a versão 0.13, há também o msgpack, que pode ser melhor para interoperabilidade, como uma alternativa mais rápida ao JSON, ou se você tiver dados de objetos / textos pesados ​​em python (consulte esta pergunta ).

Embora já existam algumas respostas, encontrei uma boa comparação na qual eles tentaram várias maneiras de serializar os DataFrames do Pandas: Armazene eficientemente os DataFrames do Pandas .

Eles comparam:

• pickle: formato de dados ASCII original
• cPickle, uma biblioteca C
• pickle-p2: usa o formato binário mais recente
• json: biblioteca json standardlib
• json-no-index: como json, mas sem index
• msgpack: alternativa JSON binária
• CSV
• hdfstore: formato de armazenamento HDF5

Em seu experimento, eles serializam um DataFrame de 1.000.000 de linhas com as duas colunas testadas separadamente: uma com dados de texto e outra com números. O aviso deles diz:

Você não deve confiar que o que se segue generalize para seus dados. Você deve examinar seus próprios dados e executar benchmarks você mesmo

O código fonte do teste ao qual eles se referem está disponível online . Como esse código não funcionou diretamente, fiz algumas pequenas alterações, que você pode obter aqui: serialize.py , obtive os seguintes resultados:

Eles também mencionam que, com a conversão de dados de texto em dados categóricos, a serialização é muito mais rápida. No teste, cerca de 10 vezes mais rápido (veja também o código do teste).

Editar : os tempos mais altos para picles que CSV podem ser explicados pelo formato de dados usado. Por padrão, pickleusa uma representação ASCII imprimível, que gera conjuntos de dados maiores. No entanto, como pode ser visto no gráfico, o pickle usando o formato de dados binários mais recente (versão 2 pickle-p2) tem tempos de carregamento muito menores.

Algumas outras referências:

• Na pergunta Biblioteca mais rápida do Python para ler um arquivo CSV, há uma resposta muito detalhada que compara bibliotecas diferentes para ler arquivos csv com uma referência. O resultado é que, para a leitura de arquivos CSV, numpy.fromfileé o mais rápido.
• Outro teste de serialização mostra que msgpack , ujson e cPickle são os mais rápidos na serialização.

Se bem entendi, você já está usando, pandas.read_csv()mas gostaria de acelerar o processo de desenvolvimento para não precisar carregar o arquivo toda vez que editar seu script, certo? Tenho algumas recomendações:

1. você pode carregar apenas parte do arquivo CSV usando pandas.read_csv(..., nrows=1000)apenas para carregar o bit superior da tabela enquanto estiver desenvolvendo

2. use o ipython para uma sessão interativa, de forma que você mantenha a tabela pandas na memória enquanto edita e recarrega seu script.

3. converter o csv em uma tabela HDF5

4. atualizados uso DataFrame.to_feather()e pd.read_feather()para armazenar dados no R-compatível pena formato binário que é super rápido (em minhas mãos, ligeiramente mais rápido do que pandas.to_pickle()em dados numéricos e muito mais rápido em dados string).

Você também pode estar interessado nesta resposta no stackoverflow.

Pickle funciona bem!

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

Você pode usar o arquivo de formato de penas. É extremamente rápido.

df.to_feather('filename.ft')

Os DataFrames do Pandas têm a to_picklefunção que é útil para salvar um 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

Como já mencionado, existem diferentes opções e formatos de arquivo ( HDF5 , JSON , CSV , parquet , SQL ) para armazenar um quadro de dados. No entanto, picklenão é um cidadão de primeira classe (dependendo da sua configuração), porque:

1. pickleé um risco potencial à segurança. Forme a documentação do Python para pickle :

Aviso O picklemódulo não é seguro contra dados incorretos ou mal-intencionados. Nunca remova os dados recebidos de uma fonte não confiável ou não autenticada.

2. pickleé lento. Encontre aqui e aqui referências.

Dependendo da sua configuração / uso, ambas as limitações não se aplicam, mas eu não recomendaria picklecomo a persistência padrão para os quadros de dados do pandas.

Formatos de arquivo numpy são bastante rápidos para dados numéricos

Prefiro usar arquivos numpy, pois eles são rápidos e fáceis de trabalhar. Aqui está uma referência simples para salvar e carregar um quadro de dados com 1 coluna de 1 milhão de pontos.

import numpy as np
import pandas as pd

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

usando a %%timeitfunção mágica do ipython

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

a saída é

100 loops, best of 3: 5.97 ms per loop

carregar os dados novamente em um dataframe

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

data_df = pd.DataFrame(data)

a saída é

100 loops, best of 3: 5.12 ms per loop

NÃO É RUIM!

CONS

Existe um problema se você salvar o arquivo numpy usando o python 2 e tentar abrir usando o python 3 (ou vice-versa).

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

Os formatos do protocolo pickle:

A versão 0 do protocolo é o protocolo “legível por humanos” original e é compatível com versões anteriores das versões anteriores do Python.

A versão 1 do protocolo é um formato binário antigo que também é compatível com versões anteriores do Python.

O protocolo versão 2 foi introduzido no Python 2.3. Ele fornece decapagem muito mais eficiente de novas classes de estilo. Consulte o PEP 307 para obter informações sobre melhorias trazidas pelo protocolo 2.

O protocolo versão 3 foi adicionado no Python 3.0. Ele possui suporte explícito para objetos de bytes e não pode ser desassociado pelo Python 2.x. Este é o protocolo padrão e o protocolo recomendado quando a compatibilidade com outras versões do Python 3 é necessária.

O protocolo versão 4 foi adicionado no Python 3.4. Ele adiciona suporte a objetos muito grandes, separando mais tipos de objetos e algumas otimizações de formato de dados. Consulte o PEP 3154 para obter informações sobre melhorias trazidas pelo protocolo 4.

compatibilidade pyarrow entre versões

O movimento geral foi o pyarrow / feather (avisos de reprovação de pandas / msgpack). No entanto, tenho um desafio com pyarrow com transiente na especificação. Dados serializados com pyarrow 0.15.1 não podem ser desserializados com 0.16.0 ARROW-7961 . Estou usando serialização para usar redis, então tenho que usar uma codificação binária.

Testei novamente várias opções (usando o notebook 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")

Com os seguintes resultados para meu quadro de dados (na outvariável 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>
=+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+==+=

plumas e parquet não funcionam para o meu quadro de dados. Vou continuar usando pyarrow. No entanto, vou suplementar com picles (sem compressão). Ao escrever no cache, armazene os formulários serializados de pyarrow e pickle. Ao ler do fallback do cache para pickle se a desserialização do pyarrow falhar.

O formato depende do seu caso de uso

• Salve o DataFrame entre as sessões do notebook - pena , se você estiver acostumado a conservar - também ok.
• Salve o DataFrame no menor tamanho de arquivo possível - parquet ou pickle.gz (verifique o que é melhor para seus dados)
• Salve um DataFrame muito grande (mais de 10 milhões de linhas) - hdf
• Consiga ler os dados em outra plataforma (não Python) que não suporta outros formatos - csv , csv.gz , verifique se o parquet é suportado
• Seja capaz de revisar com seus olhos / usando o Excel / Google Sheets / Git diff - csv
• Salve um DataFrame que consome quase toda a RAM - csv

Comparação dos formatos de arquivo pandas estão neste vídeo .