Uso de Parquet para guardar los conjuntos de datos de forma eficiente en Pandas

Los formatos de archivo para el intercambio de datos más populares actualmente son CSV y Microsoft Excel. Resultando ambos poco eficientes a la hora trabajar con grandes conjuntos de datos. CSV es un formato basado en archivos de texto plano, lo que permite su edición con cualquier editor de texto, sin la necesidad de emplear un programa específico. Aunque esto también se traduce en archivos de gran tamaño y cuyo proceso es lento. Por otro lado, Microsoft Excel es un formato diseñado para trabajar con hojas de cálculo. Actualmente, para poder trabajar de forma eficiente con grandes conjuntos de datos, se han diseñado nuevos formatos como Feather o Parquet que ofrecen archivos más pequeños, lo que ofrece importantes ahorros a la hora de almacenar los datos, y cuyas operaciones de lectura y escritura son también más rápidas, lo que reduce el tiempo de procesado.

El formato de archivo Parquet

Apache Parquet es un formato de archivo para el almacenamiento de datos orientado a columnas de código abierto del ecosistema Apache Hadoop. Por lo que es compatible con la mayoría de frameworks para el procesado de datos. En este formato, los valores de cada columna se almacenan físicamente en posiciones de contiguas, lo que consigue que la compresión de los datos sea más eficiente al ser los datos contiguos similares. Permitiendo además usar diferentes técnicas de compresión para cada columna, pudiendo adaptar esta al tipo de dato.

Parquet en Pandas

Pandas cuenta con herramientas para trabajar con archivos Parquet, por lo que no es necesario importar ningún paquete adicional. Para importar archivos Parquet en objetos DataFrame de Pandas se puede recurrir a la función read_parquet(), la cual funciona de manera similar a otras funciones como read_csv(). Además de esto los objetos DataFrame cuenta con la propiedad to_parquet(), con la que es posible volcar cualquier conjunto de datos en un archivo Parquet.

Así para guardar un conjunto de datos en este formato solamente se debería escribir

df.to_parquet('data.parquet')

asumiendo en este caso que df es un objeto DataFrame. La función permite trabajar con tres algoritmos de compresión: snappy, gzip y brotli. Por defecto se usa snappy, aunque es posible seleccionar el algoritmo usado mediante el parámetro compression. Por otro lado, la importación de los datos desde el archivo se puede conseguir simplemente con

pd.read_parquet('data.parquet')

Ventajas del formato Parquet

La utilización de Parquet, al igual que Feather, ofrece importantes ventajas frente al uso de los populares archivos CSV. Por otro lado, el uso de una estructura de datos en columnas, en lugar de en filas, hace que los procesos de lectura y escritura sean más eficientes. Además de esto, el uso nativo de compresión hace que los archivos resultantes sean mucho más pequeños. Ahorrando tanto espacio a la hora de almacenar los datos como tiempo a la hora de transferirlos a través de la red.

Comparación Parquet con Feather y CSV

Para comparar el rendimiento de los diferentes formatos se puede crear un conjunto de datos aleatorio para guardarlo y recuperar desde el disco. De forma análoga a como se ha hecho con el formato Feather.

En esta ocasión la comparación de rendimiento se va a realizar con un conjunto de datos aleatorio con 5 columnas y 2,5 millones de registros. Este conjunto de datos se guardará en un formato CSV, CSV con compresión BZ2, Feather y Parquet con compresión tipo snappy, gzip y brotli. Lo que se puede hacer con el siguiente código.

import pandas as pd
import numpy as np
import time

cols = 5
rows = 2500000

np.random.seed(0)

df = pd.DataFrame(np.random.rand(rows, cols),
                  columns=["A", "B", "C", "D", "E"])

# CSV
tic = time.process_time()
df.to_csv('data.csv')
csv_write = time.process_time() - tic

tic = time.process_time()
csv = pd.read_csv('data.csv')
csv_read = time.process_time() - tic

# bz2
tic = time.process_time()
df.to_csv('data.csv.bz2', compression='bz2')
bz2_write = time.process_time() - tic

tic = time.process_time()
csv = pd.read_csv('data.csv.bz2', compression='bz2')
bz2_read = time.process_time() - tic

# Feather
tic = time.process_time()
df.to_feather('data.feather')
feather_write = time.process_time() - tic

tic = time.process_time()
feather = pd.read_feather('data.feather')
feather_read = time.process_time() - tic

# Parquet: snappy
tic = time.process_time()
df.to_parquet('data.parquet')
parquet_write = time.process_time() - tic

tic = time.process_time()
csv = pd.read_parquet('data.parquet')
parquet_read = time.process_time() - tic

# Parquet: gzip
tic = time.process_time()
df.to_parquet('data.parquet.gzip', compression='gzip')
gzip_write = time.process_time() - tic

tic = time.process_time()
csv = pd.read_parquet('data.parquet.gzip')
gzip_read = time.process_time() - tic

# Parquet: brotli
tic = time.process_time()
df.to_parquet('data.parquet.brotli', compression='brotli')
brotli_write = time.process_time() - tic

tic = time.process_time()
csv = pd.read_parquet('data.parquet.brotli')
brotli_read = time.process_time() - tic

# Comparación de tiempos
times = pd.DataFrame({'write': [csv_write, bz2_write, feather_write, parquet_write, gzip_write, brotli_write],
                      'read': [csv_read, bz2_read, feather_read, parquet_read, gzip_read, brotli_read]},
                     index=['CSV', 'bz2', 'Feather', 'Parquet', 'gzip', 'Brotli'])

Con el que se obtienen los siguientes resultados.

En este caso se puede apreciar como CSV es el formato más lento de todos, especialmente cuando se comprime para ahorrar espacio. Por otro lado, en la tabla también se puede apreciar que Parquet con compresión tipo snappy ofrece un rendimiento en tareas de escritura y lectura similares a Feather. Incluso con archivos de tamaños similares. Aunque cuando se usan los tipos de compresión gzip o brotli los archivos se reducen de tamaño a costa de un mayor tiempo de procesado, el cual está aún muy lejos de CSV.

Conclusiones

En esta ocasión hemos visto una nueva alternativa a los archivos CSV que intenta solucionar los problemas de estos: El tamaño de los archivos y la lentitud en las operaciones de escritura y lectura. Defectos que no son visibles cuando se trabaja con pequeños conjuntos de datos, pero sin con los grandes.

Al igual que Feather, la desventaja de estos archivos es que son binarios, por lo que no se pueden leer con un simple editor de textos. Aunque en conjuntos de datos grandes tampoco es habitual la edición manual. Por lo que, en estas situaciones son una buena opción.

Respecto a Feather, el formato Parquet permite reducir aún más el tamaño de los archivos, a costa de aumentar ligeramente el tiempo de procesado. Por lo que, en la mayoría de las aplicaciones el formato Parquet sea la mejor opción para almacenar los conjuntos de datos.

Imagen de 4639459 en Pixabay