Medir y perfilar el rendimiento del código

Completados

Medir y perfilar el rendimiento del código

La notación big O predice cómo escala el código. Para obtener información sobre la rapidez con la que se ejecuta realmente el código, hay que medirlo. Cuando un programa completo es lento, se perfila para encontrar la función que causa el retraso. En esta unidad se enseñan ambas técnicas.

Medir con timeit

El módulo integrado timeit de Python mide cuánto tiempo tarda el código en ejecutarse. El código siguiente compara dos maneras de agregar los números de 0 a 999:

import timeit

def sum_with_loop():
    total = 0
    for i in range(1000):
        total += i
    return total

def sum_with_builtin():
    return sum(range(1000))

time1 = timeit.timeit(sum_with_loop, number=10000)
time2 = timeit.timeit(sum_with_builtin, number=10000)

print(f"Loop version: {time1:.4f} seconds")
print(f"Built-in version: {time2:.4f} seconds")
print(f"Built-in is {time1 / time2:.1f}x faster")
Loop version: 0.2306 seconds
Built-in version: 0.0888 seconds
Built-in is 2.6x faster

Los tiempos difieren, pero la versión integrada es más rápida.

El number=10000 argumento ejecuta la función 10 000 veces y devuelve el tiempo total. Ejecutar el código muchas veces suaviza pequeñas variaciones en la velocidad del equipo.

Ambas versiones son O(n), por lo que Big O no explica la diferencia. La función integrada sum es más rápida porque Python la ejecuta en código C optimizado, mientras que el bucle se ejecuta como código Python. Big O describe cómo crece el trabajo y la medición muestra cuánto cuesta cada paso.

Medir en distintos tamaños de datos

Para ver el patrón Big O, mide el tiempo de ejecución de la misma función con más datos. La timeit función necesita una función que no toma argumentos, por lo que encapsula una llamada que toma argumentos en un lambda contenedor, como hace el ejemplo siguiente. La función cuenta valores duplicados comparando cada par de elementos, por lo que es O(n²):

import timeit

def count_duplicates(numbers):
    count = 0
    for i in range(len(numbers)):
        for j in range(i + 1, len(numbers)):
            if numbers[i] == numbers[j]:
                count += 1
    return count

for size in [500, 1000, 2000]:
    data = list(range(size))
    time_taken = timeit.timeit(lambda: count_duplicates(data), number=3)
    print(f"{size:5d} items: {time_taken:.3f}s")
  500 items: 0.009s
 1000 items: 0.040s
 2000 items: 0.156s

Cada vez que los datos se duplican, el tiempo se cuadruplica aproximadamente. Esto coincide con el patrón O(n²) de la unidad anterior.

Decidir qué medir

No mida todas las funciones. Mida cuando:

  • Una función se ejecuta con frecuencia.
  • Una función controla grandes cantidades de datos.
  • Tiene dos enfoques y no puede decidir entre ellos.
  • Los usuarios informan de que algo es demasiado lento.

Una función que se ejecuta una vez al inicio rara vez necesita medirse. Una función que se ejecuta millones de veces sí.

Buscar el cuello de botella con cProfile

Medir el tiempo de ejecución de una función muestra la rapidez con la que se ejecuta esa función. Cuando un programa completo es lento, debe saber en qué función centrarse. Un cuello de botella es la parte de un programa que limita su velocidad global, y un generador de perfiles lo encuentra informando de dónde gasta el programa su tiempo.

El módulo integrado cProfile de Python informa cuántas veces se llamó a cada función y cuánto tiempo tardó cada una. El siguiente programa tiene tres pasos y uno de ellos es lento:

import cProfile


def load_numbers(count):
    return list(range(count))


def find_pairs(numbers, target):
    pairs = []
    for i in range(len(numbers)):
        for j in range(len(numbers)):
            if numbers[i] + numbers[j] == target:
                pairs.append((numbers[i], numbers[j]))
    return pairs


def summarize(pairs):
    return len(pairs)


def run_report():
    numbers = load_numbers(2000)
    pairs = find_pairs(numbers, 100)
    return summarize(pairs)


cProfile.run("run_report()", sort="tottime")

El argumento sort="tottime" enumera en primer lugar las funciones que más tiempo consumieron. El resultado tiene este aspecto:

         2110 function calls in 0.172 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.172    0.172    0.172    0.172 profile_example.py:8(find_pairs)
     2002    0.000    0.000    0.000    0.000 {built-in method builtins.len}
        1    0.000    0.000    0.172    0.172 profile_example.py:21(run_report)
        1    0.000    0.000    0.000    0.000 profile_example.py:4(load_numbers)
        1    0.000    0.000    0.000    0.000 profile_example.py:17(summarize)

Sus horarios y algunas líneas difieren. Estas columnas importan más:

Columna Meaning
ncalls Cuántas veces se llamó a la función.
tottime Tiempo invertido dentro de la propia función, sin contar las funciones a las que llama.
cumtime Tiempo empleado en la función y en todo lo que llama.

La función find_pairs tiene casi todo el tottime, por lo que es el cuello de botella. Los bucles anidados lo convierten en O(n²). Optimizar load_numbers o summarize no ayudaría, porque apenas requieren tiempo.

Sigue el flujo de trabajo de optimización

Siga los mismos pasos cada vez:

  1. Mida todo el programa. Anota lo lento que es.
  2. Realice un perfilado para encontrar el cuello de botella. Identifique la función con más tiempo.
  3. Mida esa función. Compruebe cuánto tiempo podría ahorrar.
  4. Optimice si vale la pena. Asegúrese de que el beneficio justifica la complejidad agregada.
  5. Vuelve a medir. Confirme que el cambio ha hecho el programa más rápido y que sigue devolviendo el mismo resultado.

Las mayores ganancias suelen provenir de un algoritmo mejor, como reemplazar un enfoque de O(n²) por un enfoque de O(n). Cambios pequeños, como quitar una variable, rara vez importan.

Evitar la optimización prematura

El científico informático Donald Knuth escribió que "la optimización prematura es la raíz de todo mal". En la práctica, esto significa:

  • No optimice el código que ya es lo suficientemente rápido.
  • No adivines dónde está el cuello de botella. Mídelo.
  • No haga que el código sea más difícil de leer para ahorrar un milisegundo.

El perfilado le permite dedicar sus esfuerzos donde más impacto tengan.