Optimización de código Python con LineProfiler

LineProfiler es una herramienta que puede ser de gran ayuda para la optimización de código Python. Debido a que permite medir el tiempo que necesita para ejecutar cada una de las líneas de un programa. Pudiendo identificar de esta manera aquellas que requieren más tiempos. Así, se pueden focalizar los esfuerzos en mejorar el rendimiento solamente de aquellas partes de código que son lentas para conseguir programas más eficientes, evitando perder tiempo mejorando el código que no requiere demasiado procesador.

Instalación de LineProfiler

La instalación de LineProfiler se puede hacer, como es habitual en los paquetes de Python, mediante el uso del comando pip. Así para agregarlo a la librería del sistema solamente se tendría que escribir en la terminal el siguiente comando:

pip install line_profiler

Depuración en un archivo de Python

Una vez instalada la librería se puede usar esta para depurar cualquier código. Por ejemplo, una función como la siguiente en la que se suman los valores entre 0 y el valor indicado. Pero, en este caso, se han agregado dos líneas al programa que detienen la ejecución durante un tiempo específico.

import time
import line_profiler


@profile
def cumsum(value=10, sleep=0.1):
    result = 0

    time.sleep(sleep * 2)

    for value in range(value + 1):
        result += value
        time.sleep(sleep)
    
    return result


if __name__ == "__main__":
    cumsum()
    print_stats()

Ahora la forma más sencilla de depurar esta función es crear un archivo Python en el que se importa la libraría line_profiler. Incluyendo en este archivo la función precedida del decorador @profile. Finalmente se debe ejecutar la función y, para ver las estadísticas de ejecución del programa, llamar a la función print_stats(). Lo que se muestra en el siguiente archivo.

Si este código se guarda en el archivo test.py para ver los resultados solamente se tendría que escribir y lanzar en la terminal el comando.

kernprof -l -v test.py

Un comando que ejecuta el código del archivo test.py y genera el archivo de profiling test.py.lprof. El parámetro -l le indica a LineProfiler que debe realizar un análisis de línea por línea, y el parámetro -v le indica que debe imprimir los resultados del análisis en la pantalla.

Una vez generado el archivo de profiling, se pueden ver los resultados con el siguiente comando:

python -m line_profiler test.py.lprof

Lo que produce por pantalla una respuesta como la siguiente.

Timer unit: 1e-06 s

Total time: 1.34155 s
File: test.py
Function: cumsun at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           @profile
     5                                           def cumsum(value=10, sleep=0.1):
     6         1          1.0      1.0      0.0      result = 0
     7                                           
     8         1     205056.0 205056.0     15.3      time.sleep(sleep * 2)
     9                                           
    10        11         71.0      6.5      0.0      for value in range(value + 1):
    11        11         44.0      4.0      0.0          result += value
    12        11    1136374.0 103306.7     84.7          time.sleep(sleep)
    13                                               
    14         1          2.0      2.0      0.0      return result

Lo que indica que la mayor parte del tiempo, concretamente el 84,5 %, el programa ha estado en la línea 12 del código. Por lo que los esfuerzos de depuración se deberían centrar en esa parte del código. El siguiente punto de interés sería la línea 8, en la que el programa pasa un 15% del tiempo. Siendo irrelevante el tiempo que le programa pasa el resto de las líneas.

Optimización de código Python en Jupyter Notebook

También es posible depurar el código Python con LineProfiler dentro de un Notebook. Aunque el proceso es ligeramente diferente. En este caso se debe importar la clase LineProfiler de la librería, crear un objeto profiler, agregar mediante el método add_function() la función que se desea analizar y ejecutar esta con el método runctx(). Una vez terminado, para ver los resultados se deberá llamar al método print_stats(). Lo que se muestra en el siguiente código.

import time
import line_profiler

profiler = LineProfiler()

def cumsum(value=25, sleep=0.5):
    result = 1

    for value in range(value):
        result += value
        time.sleep(sleep)

    return result

cumsum()

profiler.print_stats()

Conclusiones

Saber cuáles son las líneas de código de un programa que más tiempo necesitan para ejecutarse es clave para mejorar el rendimiento. Algo para lo que las hermanitas de profiling son clave. Por lo que conocer alguna para nuestro sistema es fundamental, como se vio al hablar de este tipo de herramientas para Node. En esta ocasión se ha visto el funcionamiento básico de LineProfiler, una herramienta de gran utilidad para la optimización de código Python.

Image by Hoàng Nguyên Lý from Pixabay