Búsqueda de sitios web

Cómo rastrear la asignación de memoria en Python

Este tutorial es una introducción al seguimiento de la asignación de memoria en Python utilizando el módulo tracemalloc integrado.

Al codificar en Python, normalmente no es necesario concentrarse en los detalles de la asignación de memoria. Pero rastrear la asignación de memoria puede resultar útil, especialmente si trabaja con operaciones que consumen mucha memoria y grandes conjuntos de datos.

El módulo tracemalloc integrado de Python viene con funciones que lo ayudarán a comprender el uso de la memoria y depurar aplicaciones. Con tracemalloc, puede obtener dónde y cuántos bloques de memoria se han asignado, tomar instantáneas, comparar diferencias entre instantáneas y más.

Veremos algunos de estos en este tutorial. Empecemos.

Antes de comenzar

Usaremos un script Python simple para el procesamiento de datos. Para ello, crearemos un conjunto de datos de muestra y lo procesaremos. Además de una versión reciente de Python, también necesitas pandas y NumPy en tu entorno de trabajo.

Crea un entorno virtual y actívalo:

$ python3 -m venv v1
$ source v1/bin/activate

E instale las bibliotecas requeridas:

$ pip3 install numpy pandas

Puede encontrar el código de este tutorial en GitHub.

Cree un conjunto de datos de muestra con detalles del pedido

Generaremos un archivo CSV de muestra con los detalles del pedido. Puede ejecutar el siguiente script para crear un archivo CSV con registros de pedidos de 100 000:

# create_data.py
import pandas as pd
import numpy as np

# Create a sample dataset with order details
num_orders = 100000
data = {
	'OrderID': np.arange(1, num_orders + 1),
	'CustomerID': np.random.randint(1000, 5000, num_orders),
	'OrderAmount': np.random.uniform(10.0, 1000.0, num_orders).round(2),
	'OrderDate': pd.date_range(start='2023-01-01', periods=num_orders, freq='min')
}

df = pd.DataFrame(data)
df.to_csv('order_data.csv', index=False)

Este script completa un marco de datos de pandas con 100 000 registros con las siguientes cuatro características y exporta el marco de datos a un archivo CSV:

  • OrderID: Identificador único para cada pedido
  • CustomerID: ID del cliente
  • OrderAmount: El importe de cada pedido.
  • OrderDate: la fecha y hora del pedido.

Asignación de memoria de seguimiento con tracemalloc

Ahora crearemos un script de Python para cargar y procesar el conjunto de datos. También rastrearemos las asignaciones de memoria.

Primero, definimos las funciones load_data y process_data para cargar y procesar registros del archivo CSV:

# main.py
import pandas as pd

def load_data(file_path):
    print("Loading data...")
    df = pd.read_csv(file_path)
    return df

def process_data(df):
    print("Processing data...")
    df['DiscountedAmount'] = df['OrderAmount'] * 0.9  # Apply a 10% discount
    df['OrderYear'] = pd.to_datetime(df['OrderDate']).dt.year  # Extract the order year
    return df

Luego podemos seguir adelante con el seguimiento de la asignación de memoria haciendo lo siguiente:

  • Inicialice el seguimiento de la memoria con tracemalloc.start().
  • La función load_data() lee el archivo CSV en un marco de datos. Tomamos una instantánea del uso de la memoria después de este paso.
  • La función process_data() agrega dos nuevas columnas al marco de datos: 'DiscountedAmount' y 'OrderYear'. Tomamos otra instantánea después del procesamiento.
  • Comparamos las dos instantáneas para encontrar diferencias en el uso de la memoria e imprimimos las líneas que consumen más memoria.
  • Y luego imprima el uso de memoria actual y máximo para comprender el impacto general.

Aquí está el código correspondiente:

import tracemalloc

def main():
    # Start tracing memory allocations
    tracemalloc.start()

    # Load data
    df = load_data('order_data.csv')

    # Take a snapshot
    snapshot1 = tracemalloc.take_snapshot()

    # Process data
    df = process_data(df)

    # Take another snapshot
    snapshot2 = tracemalloc.take_snapshot()

    # Compare snapshots
    top_stats = snapshot2.compare_to(snapshot1, 'lineno')

    print("[ Top memory-consuming lines ]")
    for stat in top_stats[:10]:
        print(stat)

    # Current and peak memory usage
    current, peak = tracemalloc.get_traced_memory()
    print(f"Current memory usage: {current / 1024 / 1024:.1f} MB")
    print(f"Peak usage: {peak / 1024 / 1024:.1f} MB")

    tracemalloc.stop()

if __name__ == "__main__":
    main()

Ahora ejecute el script de Python:

$ python3 main.py

Esto genera las líneas que consumen más memoria, así como el uso de memoria actual y máximo:

Loading data...
Processing data...
[ Top 3 memory-consuming lines ]
/home/balapriya/trace_malloc/v1/lib/python3.11/site-packages/pandas/core/frame.py:12683: size=1172 KiB (+1172 KiB), count=4 (+4), average=293 KiB
/home/balapriya/trace_malloc/v1/lib/python3.11/site-packages/pandas/core/arrays/datetimelike.py:2354: size=781 KiB (+781 KiB), count=3 (+3), average=260 KiB
:123: size=34.6 KiB (+15.3 KiB), count=399 (+180), average=89 B
Current memory usage: 10.8 MB
Peak usage: 13.6 MB

Concluyendo

El uso de tracemalloc para rastrear la asignación de memoria ayuda a identificar operaciones que consumen mucha memoria y potencialmente optimizar el rendimiento utilizando el rastreo de memoria y las estadísticas devueltas.

Debería poder ver si puede utilizar estructuras de datos y métodos de procesamiento más eficientes para minimizar el uso de memoria. Para aplicaciones de larga duración, puede utilizar tracemalloc periódicamente para realizar un seguimiento del uso de la memoria. Dicho esto, siempre puedes utilizar tracemalloc junto con otras herramientas de creación de perfiles para obtener una visión completa del uso de la memoria.

Si está interesado en aprender a crear perfiles de memoria con Memory-profiler, lea Introducción a los perfiles de memoria en Python.

Bala Priya C es un desarrollador y redactor técnico de la India. Le gusta trabajar en la intersección de matemáticas, programación, ciencia de datos y creación de contenido. Sus áreas de interés y experiencia incluyen DevOps, ciencia de datos y procesamiento del lenguaje natural. ¡Le gusta leer, escribir, codificar y tomar café! Actualmente, está trabajando para aprender y compartir sus conocimientos con la comunidad de desarrolladores mediante la creación de tutoriales, guías prácticas, artículos de opinión y más. Bala también crea atractivas descripciones generales de recursos y tutoriales de codificación.