Flujos de trabajo de "datos grandes" usando pandas [cerrado]

Rutinariamente uso decenas de gigabytes de datos de esta manera, por ejemplo, tengo tablas en el disco que leo a través de consultas, creo datos y las agrego.

Vale la pena leer los docs y tarde en este hilo para obtener varias sugerencias sobre cómo almacenar sus datos.

Detalles que afectarán la forma en que almacena sus datos, como:
Proporcione tantos detalles como pueda; y puedo ayudarte a desarrollar una estructura.

1. Tamaño de datos, # de filas, columnas, tipos de columnas; ¿Está agregando filas o solo columnas?
2. Cómo serán las operaciones típicas. Por ejemplo, haga una consulta en columnas para seleccionar un grupo de filas y columnas específicas, luego haga una operación (en memoria), cree nuevas columnas, guárdelas.
   (Dar un ejemplo de juguete podría permitirnos ofrecer recomendaciones más específicas).
3. Después de ese procesamiento, ¿qué haces? ¿El paso 2 es ad hoc o repetible?
4. Archivos planos de entrada: cuántos, tamaño total aproximado en Gb. ¿Cómo se organizan, por ejemplo, por registros? ¿Cada uno contiene diferentes campos, o tienen algunos registros por archivo con todos los campos en cada archivo?
5. ¿Alguna vez selecciona subconjuntos de filas (registros) en función de criterios (p. ej., seleccione las filas con el campo A > 5)? y luego hacer algo, o simplemente selecciona los campos A, B, C con todos los registros (y luego hace algo)?
6. ¿'Trabaja en' todas sus columnas (en grupos), o hay una buena proporción que solo puede usar para informes (por ejemplo, desea mantener los datos, pero no necesita extraer esa columna explícitamente hasta que tiempo de resultados finales)?

Solución

Asegúrate de que tienes al menos pandas 0.10.1 instalado.

Leer iterando archivos trozo a trozo y consultas de varias tablas.

Dado que pytables está optimizado para operar en filas (que es lo que consulta), crearemos una tabla para cada grupo de campos. De esta manera, es fácil seleccionar un pequeño grupo de campos (que funcionará con una tabla grande, pero es más eficiente hacerlo de esta manera... Creo que puedo solucionar esta limitación en el futuro... esto es más intuitivo de todos modos):
(Lo siguiente es pseudocódigo).

import numpy as np
import pandas as pd

# create a store
store = pd.HDFStore('mystore.h5')

# this is the key to your storage:
#    this maps your fields to a specific group, and defines 
#    what you want to have as data_columns.
#    you might want to create a nice class wrapping this
#    (as you will want to have this map and its inversion)  
group_map = dict(
    A = dict(fields = ['field_1','field_2',.....], dc = ['field_1',....,'field_5']),
    B = dict(fields = ['field_10',......        ], dc = ['field_10']),
    .....
    REPORTING_ONLY = dict(fields = ['field_1000','field_1001',...], dc = []),

)

group_map_inverted = dict()
for g, v in group_map.items():
    group_map_inverted.update(dict([ (f,g) for f in v['fields'] ]))

Leer los archivos y crear el almacenamiento (esencialmente hacer lo que append_to_multiple lo hace):

for f in files:
   # read in the file, additional options may be necessary here
   # the chunksize is not strictly necessary, you may be able to slurp each 
   # file into memory in which case just eliminate this part of the loop 
   # (you can also change chunksize if necessary)
   for chunk in pd.read_table(f, chunksize=50000):
       # we are going to append to each table by group
       # we are not going to create indexes at this time
       # but we *ARE* going to create (some) data_columns

       # figure out the field groupings
       for g, v in group_map.items():
             # create the frame for this group
             frame = chunk.reindex(columns = v['fields'], copy = False)    

             # append it
             store.append(g, frame, index=False, data_columns = v['dc'])

Ahora tiene todas las tablas en el archivo (en realidad, podría almacenarlas en archivos separados si lo desea, probablemente tendría que agregar el nombre del archivo a group_map, pero probablemente esto no sea necesario).

Así es como obtienes columnas y creas otras nuevas:

frame = store.select(group_that_I_want)
# you can optionally specify:
# columns = a list of the columns IN THAT GROUP (if you wanted to
#     select only say 3 out of the 20 columns in this sub-table)
# and a where clause if you want a subset of the rows

# do calculations on this frame
new_frame = cool_function_on_frame(frame)

# to 'add columns', create a new group (you probably want to
# limit the columns in this new_group to be only NEW ones
# (e.g. so you don't overlap from the other tables)
# add this info to the group_map
store.append(new_group, new_frame.reindex(columns = new_columns_created, copy = False), data_columns = new_columns_created)

Cuando esté listo para el posprocesamiento:

# This may be a bit tricky; and depends what you are actually doing.
# I may need to modify this function to be a bit more general:
report_data = store.select_as_multiple([groups_1,groups_2,.....], where =['field_1>0', 'field_1000=foo'], selector = group_1)

Acerca de data_columns, en realidad no necesita definir CUALQUIER columnas_datos; le permiten subseleccionar filas en función de la columna. Por ejemplo, algo como:

store.select(group, where = ['field_1000=foo', 'field_1001>0'])

Pueden ser más interesantes para usted en la etapa final de generación del informe (esencialmente, una columna de datos está segregada de otras columnas, lo que podría afectar un poco la eficiencia si define mucho).

También es posible que desee:

• cree una función que tome una lista de campos, busque los grupos en el mapa de grupos, luego los seleccione y concatene los resultados para obtener el marco resultante (esto es esencialmente lo que hace select_as_multiple). De esta manera, la estructura sería bastante transparente para usted.
• índices en ciertas columnas de datos (hace que el subconjunto de filas sea mucho más rápido).
• habilitar la compresión.

¡Avísame cuando tengas preguntas!

Creo que a las respuestas anteriores les falta un enfoque simple que he encontrado muy útil.

Cuando tengo un archivo que es demasiado grande para cargarlo en la memoria, divido el archivo en varios archivos más pequeños (ya sea por filas o columnas)

Ejemplo: en el caso de 30 días de datos comerciales de ~ 30 GB de tamaño, los divido en un archivo por día de ~ 1 GB de tamaño. Posteriormente, proceso cada archivo por separado y agrego los resultados al final.

Una de las mayores ventajas es que permite el procesamiento paralelo de los archivos (ya sea múltiples hilos o procesos)

La otra ventaja es que la manipulación de archivos (como agregar/eliminar fechas en el ejemplo) se puede lograr mediante comandos regulares de shell, lo que no es posible en formatos de archivo más avanzados/complicados.

Este enfoque no cubre todos los escenarios, pero es muy útil en muchos de ellos.

Ahora, dos años después de la pregunta, hay un equivalente de pandas 'fuera del núcleo': anochecer. ¡Es excelente! Aunque no es compatible con todas las funciones de pandas, puede llegar muy lejos con él. Actualización: en los últimos dos años se ha mantenido constantemente y existe una comunidad de usuarios sustancial que trabaja con Dask.

Y ahora, cuatro años después de la pregunta, hay otro equivalente de pandas 'out-of-core' de alto rendimiento en Vaex. "Utiliza mapeo de memoria, política de copia de memoria cero y cálculos perezosos para un mejor rendimiento (sin desperdicio de memoria)". Puede manejar conjuntos de datos de miles de millones de filas y no los almacena en la memoria (lo que hace posible incluso realizar análisis en hardware subóptimo).

Si sus conjuntos de datos tienen entre 1 y 20 GB, debe obtener una estación de trabajo con 48 GB de RAM. Luego, Pandas puede almacenar todo el conjunto de datos en la RAM. Sé que no es la respuesta que está buscando aquí, pero hacer computación científica en una computadora portátil con 4 GB de RAM no es razonable.

Sé que este es un hilo viejo, pero creo que el Blaze Vale la pena echarle un vistazo a la biblioteca. Está diseñado para este tipo de situaciones.

De los documentos:

Blaze amplía la usabilidad de NumPy y Pandas a la informática distribuida y fuera del núcleo. Blaze proporciona una interfaz similar a la de NumPy ND-Array o Pandas DataFrame, pero asigna estas interfaces familiares a una variedad de otros motores computacionales como Postgres o Spark.

Edit: Por cierto, cuenta con el apoyo de ContinuumIO y Travis Oliphant, autor de NumPy.

Este es el caso de pymongo. También he creado prototipos usando sql server, sqlite, HDF, ORM (SQLAlchemy) en python. En primer lugar, pymongo es una base de datos basada en documentos, por lo que cada persona sería un documento (dict de atributos). Muchas personas forman una colección y puedes tener muchas colecciones (personas, bolsa, ingresos).

pd.dateframe -> pymongo Nota: Yo uso el chunksize in read_csv para mantenerlo en 5 a 10k registros (pymongo deja caer el zócalo si es más grande)

aCollection.insert((a[1].to_dict() for a in df.iterrows()))

consultando: gt = mayor que...

pd.DataFrame(list(mongoCollection.find({'anAttribute':{'$gt':2887000, '$lt':2889000}})))

.find() devuelve un iterador, por lo que comúnmente uso ichunked para cortar en iteradores más pequeños.

¿Qué tal una unión ya que normalmente obtengo 10 fuentes de datos para pegar juntas?

aJoinDF = pandas.DataFrame(list(mongoCollection.find({'anAttribute':{'$in':Att_Keys}})))

entonces (en mi caso a veces tengo que agregar aJoinDF primero antes de su "combinable".)

df = pandas.merge(df, aJoinDF, on=aKey, how='left')

Y luego puede escribir la nueva información en su colección principal a través del método de actualización a continuación. (colección lógica vs fuentes de datos físicas).

collection.update({primarykey:foo},{key:change})

En búsquedas más pequeñas, simplemente desnormalice. Por ejemplo, tiene un código en el documento y simplemente agrega el texto del código de campo y hace una dict buscar a medida que crea documentos.

Ahora que tiene un buen conjunto de datos basado en una persona, puede desatar su lógica en cada caso y crear más atributos. Finalmente, puede leer en pandas sus indicadores clave de 3 a memoria máxima y hacer pivots/agg/exploración de datos. Esto me funciona para 3 millones de registros con números/texto grande/categorías/códigos/flotantes/...

También puede usar los dos métodos integrados en MongoDB (MapReduce y framework agregado). Consulte aquí para obtener más información sobre el marco agregado, ya que parece ser más fácil que MapReduce y parece útil para un trabajo agregado rápido. Tenga en cuenta que no necesitaba definir mis campos o relaciones, y puedo agregar elementos a un documento. En el estado actual del conjunto de herramientas numpy, pandas, python que cambia rápidamente, MongoDB me ayuda a ponerme a trabajar :)

Un truco que encontré útil para grandes datos casos de uso es reducir el volumen de los datos al reducir la precisión flotante a 32 bits. No es aplicable en todos los casos, pero en muchas aplicaciones la precisión de 64 bits es excesiva y vale la pena ahorrar el doble de memoria. Para hacer un punto obvio aún más obvio:

>>> df = pd.DataFrame(np.random.randn(int(1e8), 5))
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float64(5)
memory usage: 3.7 GB

>>> df.astype(np.float32).info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float32(5)
memory usage: 1.9 GB

Me di cuenta de esto un poco tarde, pero trabajo con un problema similar (modelos de prepago de hipoteca). Mi solución ha sido omitir la capa HDFStore de pandas y usar pytables directos. Guardo cada columna como una matriz HDF5 individual en mi archivo final.

Mi flujo de trabajo básico es obtener primero un archivo CSV de la base de datos. Lo comprimo con gzip, asi que no es tan grande. Luego, lo convierto en un archivo HDF5 orientado a filas, iterándolo en python, convirtiendo cada fila en un tipo de datos real y escribiéndolo en un archivo HDF5. Eso toma algunas decenas de minutos, pero no usa memoria, ya que solo está operando fila por fila. Luego "transpongo" el archivo HDF5 orientado a filas en un archivo HDF5 orientado a columnas.

La transposición de la tabla se ve así:

def transpose_table(h_in, table_path, h_out, group_name="data", group_path="/"):
    # Get a reference to the input data.
    tb = h_in.getNode(table_path)
    # Create the output group to hold the columns.
    grp = h_out.createGroup(group_path, group_name, filters=tables.Filters(complevel=1))
    for col_name in tb.colnames:
        logger.debug("Processing %s", col_name)
        # Get the data.
        col_data = tb.col(col_name)
        # Create the output array.
        arr = h_out.createCArray(grp,
                                 col_name,
                                 tables.Atom.from_dtype(col_data.dtype),
                                 col_data.shape)
        # Store the data.
        arr[:] = col_data
    h_out.flush()

Leerlo de nuevo entonces parece:

def read_hdf5(hdf5_path, group_path="/data", columns=None):
    """Read a transposed data set from a HDF5 file."""
    if isinstance(hdf5_path, tables.file.File):
        hf = hdf5_path
    else:
        hf = tables.openFile(hdf5_path)

    grp = hf.getNode(group_path)
    if columns is None:
        data = [(child.name, child[:]) for child in grp]
    else:
        data = [(child.name, child[:]) for child in grp if child.name in columns]

    # Convert any float32 columns to float64 for processing.
    for i in range(len(data)):
        name, vec = data[i]
        if vec.dtype == np.float32:
            data[i] = (name, vec.astype(np.float64))

    if not isinstance(hdf5_path, tables.file.File):
        hf.close()
    return pd.DataFrame.from_items(data)

Ahora, generalmente ejecuto esto en una máquina con una tonelada de memoria, por lo que es posible que no sea lo suficientemente cuidadoso con el uso de mi memoria. Por ejemplo, de forma predeterminada, la operación de carga lee todo el conjunto de datos.

Por lo general, esto funciona para mí, pero es un poco torpe y no puedo usar la elegante magia de pytables.

Editar: la ventaja real de este enfoque, sobre el valor predeterminado de pytables de matriz de registros, es que luego puedo cargar los datos en R usando h5r, que no puede manejar tablas. O, al menos, no he podido hacer que cargue tablas heterogéneas.

Como señalaron otros, después de algunos años ha surgido un equivalente de pandas 'fuera del núcleo': anochecer. Aunque dask no es un reemplazo directo de pandas y toda su funcionalidad, se destaca por varias razones:

Dask es una biblioteca de computación paralela flexible para computación analítica que está optimizada para la programación dinámica de tareas para cargas de trabajo computacionales interactivas de colecciones de "Big Data" como arreglos paralelos, marcos de datos y listas que extienden interfaces comunes como NumPy, Pandas o iteradores de Python a más grandes. Entornos que no sean de memoria o distribuidos y escalables desde portátiles hasta clústeres.

Dask destaca las siguientes virtudes:

• Familiar: proporciona una matriz NumPy paralelizada y objetos Pandas DataFrame
• Flexible: proporciona una interfaz de programación de tareas para cargas de trabajo más personalizadas e integración con otros proyectos.
• Nativo: permite la computación distribuida en Pure Python con acceso a la pila de PyData.
• Rápido: funciona con poca sobrecarga, baja latencia y serialización mínima necesaria para algoritmos numéricos rápidos
• Escala hacia arriba: se ejecuta de manera resistente en clústeres con miles de núcleos. Escala hacia abajo: trivial para configurar y ejecutar en una computadora portátil en un solo proceso.
• Receptivo: diseñado con la informática interactiva en mente, proporciona comentarios y diagnósticos rápidos para ayudar a los humanos.

y para agregar una muestra de código simple:

import dask.dataframe as dd
df = dd.read_csv('2015-*-*.csv')
df.groupby(df.user_id).value.mean().compute()

reemplaza algunos códigos de pandas como este:

import pandas as pd
df = pd.read_csv('2015-01-01.csv')
df.groupby(df.user_id).value.mean()

y, especialmente destacable, proporciona a través de la concurrent.futures interfaz una infraestructura general para el envío de tareas personalizadas:

from dask.distributed import Client
client = Client('scheduler:port')

futures = []
for fn in filenames:
    future = client.submit(load, fn)
    futures.append(future)

summary = client.submit(summarize, futures)
summary.result()

Vale la pena mencionar aquí Ray también,
es un marco de computación distribuida, que tiene su propia implementación para pandas de forma distribuida.

Simplemente reemplace la importación de pandas, y el código debería funcionar como está:

# import pandas as pd
import ray.dataframe as pd

# use pd as usual

Puede leer más detalles aquí:

https://rise.cs.berkeley.edu/blog/pandas-on-ray/

Actualización: la parte que maneja la distribución de pandas, ha sido extraída al modín proyecto.

la forma correcta de usarlo ahora es:

# import pandas as pd
import modin.pandas as pd

Una variación más

Muchas de las operaciones realizadas en pandas también se pueden realizar como una consulta de base de datos (sql, mongo)

El uso de un RDBMS o mongodb le permite realizar algunas de las agregaciones en DB Query (que está optimizado para grandes datos y usa caché e índices de manera eficiente)

Más tarde, puede realizar un procesamiento posterior utilizando pandas.

La ventaja de este método es que obtiene las optimizaciones de la base de datos para trabajar con datos de gran tamaño, al mismo tiempo que define la lógica en una sintaxis declarativa de alto nivel, y no tiene que lidiar con los detalles de decidir qué hacer en la memoria y qué hacer. de núcleo.

Y aunque el lenguaje de consulta y los pandas son diferentes, no suele ser complicado traducir parte de la lógica de uno a otro.

Imagine Ruffus si sigue el camino simple de crear una canalización de datos que se divide en varios archivos más pequeños.

Me gustaría señalar el paquete Vaex.

Vaex es una biblioteca de python para marcos de datos perezosos fuera del núcleo (similar a Pandas), para visualizar y explorar grandes conjuntos de datos tabulares. Puede calcular estadísticas como la media, la suma, el conteo, la desviación estándar, etc., en una cuadrícula N-dimensional de hasta mil millones (10⁹) objetos/filas por segundo. La visualización se realiza mediante histogramas, diagramas de densidad y representación de volumen 3D, lo que permite la exploración interactiva de big data. Vaex utiliza mapeo de memoria, política de copia de memoria cero y cálculos perezosos para un mejor rendimiento (sin desperdicio de memoria).

Eche un vistazo a la documentación: https://vaex.readthedocs.io/en/latest/ La API está muy cerca de la API de pandas.

Recientemente me encontré con un problema similar. Descubrí que simplemente leer los datos en fragmentos y agregarlos mientras los escribo en fragmentos en el mismo csv funciona bien. Mi problema fue agregar una columna de fecha basada en información en otra tabla, usando el valor de ciertas columnas de la siguiente manera. Esto puede ayudar a aquellos confundidos por dask y hdf5 pero más familiarizados con pandas como yo.

def addDateColumn():
"""Adds time to the daily rainfall data. Reads the csv as chunks of 100k 
   rows at a time and outputs them, appending as needed, to a single csv. 
   Uses the column of the raster names to get the date.
"""
    df = pd.read_csv(pathlist[1]+"CHIRPS_tanz.csv", iterator=True, 
                     chunksize=100000) #read csv file as 100k chunks

    '''Do some stuff'''

    count = 1 #for indexing item in time list 
    for chunk in df: #for each 100k rows
        newtime = [] #empty list to append repeating times for different rows
        toiterate = chunk[chunk.columns[2]] #ID of raster nums to base time
        while count <= toiterate.max():
            for i in toiterate: 
                if i ==count:
                    newtime.append(newyears[count])
            count+=1
        print "Finished", str(chunknum), "chunks"
        chunk["time"] = newtime #create new column in dataframe based on time
        outname = "CHIRPS_tanz_time2.csv"
        #append each output to same csv, using no header
        chunk.to_csv(pathlist[2]+outname, mode='a', header=None, index=None)

El formato de archivo de parquet es ideal para el caso de uso que describió. Puede leer eficientemente en un subconjunto específico de columnas con pd.read_parquet(path_to_file, columns=["foo", "bar"])

https://pandas.pydata.org/docs/reference/api/pandas.read_parquet.html

En este momento estoy trabajando "como" usted, solo que en una escala más baja, por lo que no tengo un PoC para mi sugerencia.

Sin embargo, parece que tengo éxito al usar pickle como sistema de almacenamiento en caché y subcontratar la ejecución de varias funciones en archivos, ejecutando estos archivos desde mi comando/archivo principal; Por ejemplo, uso un prepare_use.py para convertir tipos de objetos, dividir un conjunto de datos en un conjunto de datos de prueba, validación y predicción.

¿Cómo funciona el almacenamiento en caché con pickle? Utilizo cadenas para acceder a los archivos pickle que se crean dinámicamente, según los parámetros y conjuntos de datos que se pasaron (con eso trato de capturar y determinar si el programa ya se ejecutó, usando .shape para el conjunto de datos, dict para pasado parámetros). Respetando estas medidas, obtengo una cadena para tratar de encontrar y leer un archivo .pickle y puedo, si lo encuentra, omitir el tiempo de procesamiento para saltar a la ejecución en la que estoy trabajando en este momento.

Al usar bases de datos, encontré problemas similares, por lo que me alegró usar esta solución; sin embargo, hay muchas limitaciones, por ejemplo, almacenar grandes conjuntos de pepinillos debido a la redundancia. La actualización de una tabla de antes a después de una transformación se puede hacer con la indexación adecuada: la validación de la información abre otro libro (intenté consolidar los datos de alquiler rastreados y dejé de usar una base de datos después de 2 horas básicamente, ya que me hubiera gustado volver atrás después cada proceso de transformación)

Espero que mis 2 centavos te ayuden de alguna manera.

Saludos.