Optimización del rendimiento de Pandas: Dominar la reducción del uso de memoria

Pandas es una potente biblioteca de Python para el análisis de datos, que proporciona estructuras de datos flexibles y herramientas de análisis de datos. Sin embargo, cuando se trabaja con grandes conjuntos de datos, el uso de memoria puede convertirse en un cuello de botella importante, que afecta al rendimiento e incluso provoca que los programas se bloqueen. Esta completa guía explora varias técnicas para optimizar el uso de memoria de Pandas, lo que le permite manejar conjuntos de datos más grandes de forma más eficiente y eficaz.

Comprensión del uso de memoria de Pandas

Antes de sumergirse en las técnicas de optimización, es fundamental comprender cómo Pandas almacena los datos en la memoria. Pandas utiliza principalmente matrices NumPy para almacenar datos dentro de DataFrames y Series. El tipo de datos de cada columna afecta significativamente a la huella de memoria. Por ejemplo, una columna `int64` consumirá el doble de memoria que una columna `int32`.

Puede comprobar el uso de memoria de un DataFrame utilizando el método .memory_usage():

            import pandas as pd

data = {
    'col1': [1, 2, 3, 4, 5],
    'col2': ['A', 'B', 'C', 'D', 'E'],
    'col3': [1.1, 2.2, 3.3, 4.4, 5.5]
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)

            

              
                Copy
              
            
          

El argumento deep=True es esencial para calcular con precisión el uso de memoria de las columnas de objeto (cadena).

Técnicas para reducir el uso de memoria

1. Seleccionar los tipos de datos correctos

Elegir el tipo de datos adecuado para cada columna es el paso más fundamental para reducir el uso de memoria. Pandas infiere automáticamente los tipos de datos, pero a menudo utiliza tipos que consumen más memoria de lo necesario. Por ejemplo, a una columna que contiene enteros entre 0 y 100 se le podría asignar el tipo `int64`, aunque `int8` o `uint8` serían suficientes.

Ejemplo: Reducción de tipos numéricos

Puede reducir los tipos numéricos a representaciones más pequeñas utilizando la función pd.to_numeric() con el parámetro downcast:

            def reduce_mem_usage(df):
    """Iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        if df[col].dtype == 'object':
            continue # Skip strings, handle them separately

        col_type = df[col].dtype
        
        if col_type in ['int64','int32','int16']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                df[col] = df[col].astype(np.int8)
            elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                df[col] = df[col].astype(np.int16)
            elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                df[col] = df[col].astype(np.int32)
            else:
                df[col] = df[col].astype(np.int64)
        elif col_type in ['float64','float32']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                df[col] = df[col].astype(np.float16)
            elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                df[col] = df[col].astype(np.float32)
            else:
                df[col] = df[col].astype(np.float64)

    end_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

            

              
                Copy
              
            
          

Ejemplo: Conversión de cadenas a tipos categóricos

Si una columna contiene un número limitado de valores de cadena únicos, la conversión a un tipo categórico puede reducir significativamente el uso de memoria. Los tipos categóricos almacenan los valores únicos sólo una vez y representan cada elemento de la columna como un código entero que hace referencia a los valores únicos.

            df['col2'] = df['col2'].astype('category')

            

              
                Copy
              
            
          

Considere un conjunto de datos de transacciones de clientes para una plataforma global de comercio electrónico. La columna "País" puede contener sólo unos cientos de nombres de países únicos, mientras que el conjunto de datos contiene millones de transacciones. La conversión de la columna "País" a un tipo categórico reduciría drásticamente el consumo de memoria.

2. Chunking e iteración

Cuando se trabaja con conjuntos de datos extremadamente grandes que no caben en la memoria, puede procesar los datos en trozos utilizando el parámetro chunksize en pd.read_csv() o pd.read_excel(). Esto le permite cargar y procesar los datos en piezas más pequeñas y manejables.

            for chunk in pd.read_csv('large_dataset.csv', chunksize=100000):
    # Process the chunk (e.g., perform calculations, filtering, aggregation)
    print(f"Processing chunk with {len(chunk)} rows")
    # Optionally, append results to a file or database.

            

              
                Copy
              
            
          

Ejemplo: Procesamiento de archivos de registro grandes

Imagine que está procesando un archivo de registro masivo de una infraestructura de red global. El archivo de registro es demasiado grande para caber en la memoria. Mediante el uso de chunking, puede iterar a través del archivo de registro, analizar cada trozo para eventos o patrones específicos y agregar los resultados sin exceder los límites de memoria.

3. Seleccionar sólo las columnas necesarias

A menudo, los conjuntos de datos contienen columnas que no son relevantes para su análisis. Cargar sólo las columnas necesarias puede reducir significativamente el uso de memoria. Puede especificar las columnas deseadas utilizando el parámetro usecols en pd.read_csv().

            df = pd.read_csv('large_dataset.csv', usecols=['col1', 'col2', 'col3'])

            

              
                Copy
              
            
          

Ejemplo: Análisis de datos de ventas

Si está analizando los datos de ventas para identificar los productos con mejor rendimiento, es posible que sólo necesite las columnas "ID del producto", "Cantidad de ventas" e "Ingresos por ventas". La carga sólo de estas columnas reducirá el consumo de memoria en comparación con la carga de todo el conjunto de datos, que podría incluir datos demográficos de los clientes, direcciones de envío y otra información irrelevante.

4. Uso de estructuras de datos dispersos

Si su DataFrame contiene muchos valores que faltan (NaN) o ceros, puede utilizar estructuras de datos dispersos para representar los datos de forma más eficiente. Los DataFrames dispersos almacenan sólo los valores no faltantes o no cero, lo que reduce significativamente el uso de memoria cuando se trabaja con datos dispersos.

            sparse_series = df['col1'].astype('Sparse[float]')
sparse_df = sparse_series.to_frame()

            

              
                Copy
              
            
          

Ejemplo: Análisis de calificaciones de clientes

Considere un conjunto de datos de calificaciones de clientes para un gran número de productos. La mayoría de los clientes sólo calificarán un pequeño subconjunto de productos, lo que resultará en una matriz dispersa de calificaciones. El uso de un DataFrame disperso para almacenar estos datos reducirá significativamente el consumo de memoria en comparación con un DataFrame denso.

5. Evitar la copia de datos

Las operaciones de Pandas a veces pueden crear copias de DataFrames, lo que lleva a un mayor uso de memoria. La modificación de un DataFrame en su lugar (cuando sea posible) puede ayudar a evitar copias innecesarias.

Por ejemplo, en lugar de:

            df = df[df['col1'] > 10]

            

              
                Copy
              
            
          

Considere usar:

            df.drop(df[df['col1'] <= 10].index, inplace=True)

            

              
                Copy
              
            
          

El argumento inplace=True modifica el DataFrame directamente sin crear una copia.

6. Optimización del almacenamiento de cadenas

Las columnas de cadena pueden consumir una cantidad significativa de memoria, especialmente si contienen cadenas largas o muchos valores únicos. La conversión de cadenas a tipos categóricos, como se mencionó anteriormente, es una técnica eficaz. Otro enfoque es utilizar representaciones de cadena más pequeñas si es posible.

Ejemplo: Reducción de la longitud de la cadena

Si una columna contiene identificadores que se almacenan como cadenas pero podrían representarse como enteros, la conversión a enteros puede ahorrar memoria. Por ejemplo, los ID de producto que actualmente se almacenan como cadenas como "PROD-1234" podrían asignarse a ID enteros.

7. Uso de Dask para conjuntos de datos más grandes que la memoria

Para los conjuntos de datos que son realmente demasiado grandes para caber en la memoria, incluso con chunking, considere usar Dask. Dask es una biblioteca de computación paralela que se integra bien con Pandas y NumPy. Le permite trabajar con conjuntos de datos más grandes que la memoria dividiéndolos en trozos más pequeños y procesándolos en paralelo en múltiples núcleos o incluso en múltiples máquinas.

            import dask.dataframe as dd

ddf = dd.read_csv('large_dataset.csv')

# Perform operations on the Dask DataFrame (e.g., filtering, aggregation)
result = ddf[ddf['col1'] > 10].groupby('col2').mean().compute()

            

              
                Copy
              
            
          

El método compute() activa el cálculo real y devuelve un Pandas DataFrame que contiene los resultados.

Prácticas recomendadas y consideraciones

• Perfile su código: Utilice herramientas de perfiles para identificar los cuellos de botella de memoria y centre sus esfuerzos de optimización en las áreas de mayor impacto.
• Pruebe diferentes técnicas: La técnica óptima de reducción de memoria depende de las características específicas de su conjunto de datos. Experimente con diferentes enfoques para encontrar la mejor solución para su caso de uso.
• Supervise el uso de la memoria: Realice un seguimiento del uso de la memoria durante el procesamiento de datos para asegurarse de que sus optimizaciones sean efectivas y evitar errores de falta de memoria.
• Comprenda sus datos: Una comprensión profunda de sus datos es crucial para elegir los tipos de datos y las técnicas de optimización más apropiados.
• Considere las compensaciones: Algunas técnicas de optimización de memoria podrían introducir una ligera sobrecarga de rendimiento. Sopesar los beneficios de la reducción del uso de memoria frente a cualquier impacto potencial en el rendimiento.
• Documente sus optimizaciones: Documente claramente las técnicas de optimización de memoria que ha implementado para asegurarse de que su código sea mantenible y comprensible por otros.

Conclusión

La optimización del uso de memoria de Pandas es esencial para trabajar con grandes conjuntos de datos de forma eficiente y eficaz. Al comprender cómo Pandas almacena los datos, seleccionar los tipos de datos correctos, utilizar el chunking y emplear otras técnicas de optimización, puede reducir significativamente el consumo de memoria y mejorar el rendimiento de sus flujos de trabajo de análisis de datos. Esta guía ha proporcionado una visión general completa de las técnicas clave y las mejores prácticas para dominar la reducción del uso de memoria en Pandas. Recuerde perfilar su código, probar diferentes técnicas y supervisar el uso de la memoria para lograr los mejores resultados para su caso de uso específico. Al aplicar estos principios, puede desbloquear todo el potencial de Pandas y abordar incluso los desafíos de análisis de datos más exigentes.

Al dominar estas técnicas, los científicos y analistas de datos de todo el mundo pueden manejar conjuntos de datos más grandes, mejorar la velocidad de procesamiento y obtener conocimientos más profundos de sus datos. Esto contribuye a una investigación más eficiente, a decisiones empresariales mejor informadas y, en última instancia, a un mundo más impulsado por los datos.