Saltearse al contenido

Vectorizar con numpy

Cuando el cuello de botella es un bucle que recorre un millón de números, no hay truco de Python que lo arregle: hay que salir de Python. numpy guarda los datos en bloques contiguos sin objetos y ejecuta las operaciones en C sobre todo el bloque. No es una biblioteca más rápida: es otro modelo de ejecución.

Un bucle de Python hace n llamadas; una operación de numpy hace una.

Un millón de enteros
Operación list array numpy
Sumar todo 5.66 ms 11.62 ms 0.348 ms (16×)
x * 2 + 1 61.33 ms — 3.75 ms (16×)
Filtrar por condición 40.44 ms — 5.91 ms (7×)

python mediciones/05-05-07-optimizar-numpy-cache.py

Dos resultados importan.

El primero: array es más lento que list para sumar (11,62 contra 5,66 ms). sum() sobre un array convierte cada valor en un objeto int para poder sumarlo; sobre una lista ya son objetos. array ahorra memoria y no acelera: es la advertencia del capítulo 04 de la Parte II, confirmada aquí.

El segundo: el filtrado gana menos (7×) que la suma (16×), porque una máscara booleana recorre los datos dos veces: una para calcularla y otra para aplicarla. Sigue ganando, y menos.

Estructura Bytes por elemento
list de int 8 de puntero más 28 del objeto
array('i') 4
ndarray de int64 8

La lista de un millón de enteros pesa unos 40 MB; el ndarray, 8. Ese ahorro es tan importante como la velocidad, y aparece antes: el programa que no cabe no llega a ser lento.

  • Datos numéricos homogéneos de más de unos miles de elementos.
  • Operaciones que se aplican a todo (suma, media, transformación, comparación).
  • Álgebra lineal, donde la biblioteca usa BLAS y varios núcleos.
  • Series temporales y matrices, donde el dato ya es un array por naturaleza.
  • Con pocos elementos. Una operación de numpy tiene coste fijo (~1 µs); con cien elementos, la lista gana.
  • Con datos heterogéneos. Un ndarray de objetos (dtype=object) pierde todo el beneficio y añade indirección.
  • Con una sola pasada que hace muchas cosas distintas. Tres operaciones de numpy son tres recorridos; un bucle que lo hace todo en una pasada puede ganar.
  • Si necesitas exactitud decimal. numpy usa float64; para dinero, Decimal (Parte I, capítulo 07).
  • Si no puedes añadir la dependencia. Es una decisión de despliegue, no técnica.
  • En scripts de menos de 10 000 elementos, donde el coste fijo domina.
  • Si el dato es texto o mixto, donde pandas o Python puro son mejores.
  • Para una sola operación. sum(lista) es una línea y no arrastra 30 MB de biblioteca.

Una función calcula, para un millón de filas, la media de precio donde categoria == "A" y cantidad > 0. Escribe la versión numpy y explica por qué la versión con listas no es tan lenta como esperarías.

Solución
try:
import numpy as np
except ImportError:
np = None
print("Este ejercicio necesita numpy: pip install numpy")
def media_a(precios, categorias, cantidades):
mascara = (categorias == "A") & (cantidades > 0)
return precios[mascara].mean()

categorias == "A" produce un array de booleanos; & combina las dos condiciones sin bucles. El resultado son tres recorridos completos (dos comparaciones y el filtrado) más la media.

La versión con listas no es 16 veces más lenta porque la condición se evalúa en una sola pasada con zip:

def media_a_listas(precios, categorias, cantidades):
seleccion = [p for p, c, q in zip(precios, categorias, cantidades)
if c == "A" and q > 0]
return sum(seleccion) / len(seleccion) if seleccion else 0.0

Esa versión hace una pasada con tres operaciones dentro; la de numpy hace tres pasadas sobre bloques contiguos. La ganancia real suele estar entre 4 y 8 veces, no en 16, y el capítulo lo dice: el número depende de cuántas pasadas necesites. Si el dato cabe en un ndarray desde el principio (sin conversión), la ventaja crece.

Comprobación con datos de ejemplo:

precios_l = [10.0, 20.0, 30.0, 40.0, 50.0]
categorias_l = ["A", "B", "A", "A", "B"]
cantidades_l = [1, 5, 0, 3, 2]
print("listas:", media_a_listas(precios_l, categorias_l, cantidades_l))
if np is not None:
r = media_a(np.array(precios_l), np.array(categorias_l), np.array(cantidades_l))
print("numpy:", float(r))
assert float(r) == media_a_listas(precios_l, categorias_l, cantidades_l), "ambas versiones coinciden"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 2: array y memoryview.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 12.
  • Mediciones: mediciones/05-05-07-optimizar-numpy-cache.py (requiere numpy).
  • 04 · array y memoryview (Parte II): la misma idea sin dependencias.
  • 05 · Optimizar sin mentir: medir antes de reescribir.
  • 07 · Cachés: la otra forma de no repetir trabajo.