web-dev-qa-db-fra.com

Quelles sont les différences entre plume et parquet?

Les deux sont des formats de stockage en colonnes (sur disque) destinés aux systèmes d'analyse de données. Les deux sont intégrés dans Apache Arrow ( pyarrow paquet pour python) et sont conçus pour correspondre à Arrow en tant que couche analytique en mémoire en colonne.

Comment les deux formats diffèrent?

Devez-vous toujours préférer les plumes lorsque vous travaillez avec pandas lorsque cela est possible?)

Quels sont les cas d'utilisation où plume est plus approprié que parquet et inversement?

Appendice

J'ai trouvé quelques indices ici https://github.com/wesm/feather/issues/188 , mais étant donné le jeune âge de ce projet, il est peut-être un peu dépassé.

Ce n’est pas un test de vitesse sérieux, car je ne fais que décharger et charger tout un Dataframe, mais pour vous donner une impression si vous n’avez jamais entendu parler des formats auparavant:

 # IPython    
import numpy as np
import pandas as pd
import pyarrow as pa
import pyarrow.feather as feather
import pyarrow.parquet as pq
import fastparquet as fp


df = pd.DataFrame({'one': [-1, np.nan, 2.5],
                   'two': ['foo', 'bar', 'baz'],
                   'three': [True, False, True]})

print("pandas df to disk ####################################################")
print('example_feather:')
%timeit feather.write_feather(df, 'example_feather')
# 2.62 ms ± 35.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print('example_parquet:')
%timeit pq.write_table(pa.Table.from_pandas(df), 'example.parquet')
# 3.19 ms ± 51 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print()

print("for comparison:")
print('example_pickle:')
%timeit df.to_pickle('example_pickle')
# 2.75 ms ± 18.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print('example_fp_parquet:')
%timeit fp.write('example_fp_parquet', df)
# 7.06 ms ± 205 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
print('example_hdf:')
%timeit df.to_hdf('example_hdf', 'key_to_store', mode='w', table=True)
# 24.6 ms ± 4.45 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)
print()

print("pandas df from disk ##################################################")
print('example_feather:')
%timeit feather.read_feather('example_feather')
# 969 µs ± 1.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
print('example_parquet:')
%timeit pq.read_table('example.parquet').to_pandas()
# 1.9 ms ± 5.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

print("for comparison:")
print('example_pickle:')
%timeit pd.read_pickle('example_pickle')
# 1.07 ms ± 6.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
print('example_fp_parquet:')
%timeit fp.ParquetFile('example_fp_parquet').to_pandas()
# 4.53 ms ± 260 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
print('example_hdf:')
%timeit pd.read_hdf('example_hdf')
# 10 ms ± 43.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

# pandas version: 0.22.0
# fastparquet version: 0.1.3
# numpy version: 1.13.3
# pandas version: 0.22.0
# pyarrow version: 0.8.0
# sys.version: 3.6.3
# example Dataframe taken from https://arrow.Apache.org/docs/python/parquet.html
pythonpandasparquetfeatherpyarrow
39
Darkonaut

  • Le format de parquet est conçu pour un stockage à long terme, où Arrow est davantage destiné à un stockage à court terme ou éphémère (Arrow peut être plus approprié pour un stockage à long terme après la parution de la version 1.0.0, car le format binaire sera alors stable)

  • L'écriture du parquet est plus coûteuse que celle de Feather, car il comporte davantage de couches d'encodage et de compression. Feather est une mémoire de colonne brute non modifiée en colonne. Nous allons probablement ajouter une compression simple à Feather dans le futur.

  • En raison de l'encodage du dictionnaire, de l'encodage RLE et de la compression de la page de données, les fichiers Parquet sont souvent beaucoup plus petits que les fichiers Feather.

  • Parquet est un format de stockage standard pour les analyses pris en charge par de nombreux systèmes différents: Spark, Hive, Impala, divers services AWS, à l'avenir par BigQuery, etc. Ainsi, si vous effectuez des analyses, Parquet est un bon choix en tant que format de stockage de référence pour requête par plusieurs systèmes

Les repères que vous avez montrés vont être très bruyants car les données que vous avez lues et écrites sont très petites. Vous devriez essayer de compresser au moins 100 Mo ou plus d'1 Go de données pour obtenir des données de référence plus informatives, voir par exemple. http://wesmckinney.com/blog/python-parquet-multithreading/

J'espère que cela t'aides

62
Wes McKinney