En los entornos intensivos en datos es habitual tener que aplicar una misma función a grandes conjuntos de datos. Los cuales pueden estar almacenados en listas o tuplas. Lo que puede ser necesario desde para la creación de los datos de una gráfica hasta para obtener los valores de una simulación de tipo Montecarlo. Para lo que no existe una única forma de realizar esta tarea, sino que hay varias. En esta entrada se van a utilizar cinco aproximaciones para iterar sobre un conjunto de datos y medir su rendimiento. Con lo que se puede obtener así una idea de cual es las mejores aproximaciones para iterar en Python.
El problema que se va a utiliza de ejemplo en esta entrada es sencillo. Se va a calcular los valores de aplicar la siguiente función a un conjunto de datos grande
1 - \log(x+1)Utilizando para ellos las diferentes aproximaciones disponibles en Python.
Aproximaciones básicas disponibles en Python
Una vez planteado el problema se puede ver que en Python existen tres métodos básicos de realizar esta tarea. Estos son:
- Bucles: esta es la manera más sencilla e intuitiva. Para su implementación solamente es necesario definir un
forque itere sobre los valores. - Iteradores: son un paso más allá de los bucles. Al igual que en los bucles se han de indicar mediante un
forlos valores sobre los que es necesario iterar. - La vectorización NumPy: otra forma sencilla de implementar esta tarea es aprovechar que es posible aplicar una función sobre un objeto NumPy directamente.
Las tres aproximaciones anteriores se muestran en el siguiente código. Los bucles se implementan con la función loops, los iteradores mediante iterators y la vectorización NumPy mediante numpy_vectorization.
from math import log
import numpy as np
def loops(num):
result = []
for x in range(num):
result.append(1 - log(x + 1))
return result
def iterators(num):
return [1 - log(x + 1) for x in range(num)]
def numpy_vectorization(num):
return (1 - np.log(np.arange(num) + 1))
Comparación de los resultados
Para comparar el rendimiento de las tres funciones se va a utilizar la función repeat de la librería timeit. Esta función permite repetir un método una cantidad de veces y devuelve el tiempo necesario cada vez. Una función que ofrece los resultados es:
from timeit import repeat
import operator
def performance(func_name, iterations= 250000, rep=10, number=1):
results = {}
for name in func_name:
stmt = name + '(' + str(iterations) + ')'
setup = 'from __main__ import ' + name
outputs = repeat(stmt=stmt,
setup=setup,
repeat=rep,
number=number)
results[name] = sum(outputs) / rep
results_sorted = sorted(results.items(), key=operator.itemgetter(1))
for item in results_sorted:
print(item[0] + ' requires %1.3f seconds and is %1.1f times slower than the best' % (item[1], item[1] / results_sorted[0][1]))
return results
En esta función se crea inicialmente una cadena de texto con la función a evaluar que se almacena en stmt. Posteriormente es necesario configura otra cadena de texto para que se pueden importar los objetos del espacio de trabajo. Finalmente se ejecuta el método el número de veces indicado en las opciones.
Una vez obtenido los tiempos estos se ordenan y se saca por pantalla los resultados. Para los tres casos anteriores se obtiene.
times = performance(('loops', 'iterators', 'numpy_vectorization'))
numpy_vectorization requires 0.002 seconds and is 1.0 times slower than the best option
iterators requires 0.041 seconds and is 20.2 times slower than the best option
loops requires 0.053 seconds and is 26.4 times slower than the best option
En este ejemplo se puede ver que NumPy es la opción más rápida de las tres. Tanto los iteradores como los bucles son 20 veces más lentos.
Evaluador rápido de expresiones y NumExpr
Como alternativa a los métodos vistos anteriormente se puede plantear la evaluación de expresiones. En Python existe para ello la función eval, aunque más interesante es la librería NumExpr disponible mediante pip. NumExpr es un evaluador rápido de expresiones numéricas para NumPy que permite obtener un gran rendimiento. Permitiendo que las expresiones que operan en arrays se ejecuten de forma más rápida y con menos consumo de memoria que en Python.
A continuación, se muestra la implementación de ambos para el problema planteado. La evaluación de Python se implementa mediante la función evaluator y la de NumExpr con evaluator_numexpr.
import numexpr as ne
def evaluator(num):
return [eval('1 - log(x + 1)') for x in range(num)]
def evaluator_numexpr(num):
values = np.arange(num)
return ne.evaluate('1 - log(values + 1)')
Comparación de todos los resultados
Ahora se puede llevar a cabo la comparación del rendimiento de todas las aproximaciones anteriores. Para ello se puede utilizar la misma función que se ha definido para las tres primeras.
times = performance(('loops', 'iterators', 'numpy_vectorization', 'evaluator', 'evaluator_numexpr'))
evaluator_numexpr requires 0.001 seconds and is 1.0 times slower than the best option
numpy_vectorization requires 0.002 seconds and is 2.5 times slower than the best option
iterators requires 0.039 seconds and is 59.3 times slower than the best option
loops requires 0.051 seconds and is 77.0 times slower than the best option
evaluator requires 1.775 seconds and is 2675.1 times slower than the best option
En este caso se puede observar como el método más rápido es evaluator_numepr, el cual requiere menos de la mitad de tiempo que numpy_vectorization. Lo que es una mejora considerable. Por otro lado, la peor opción la función que utilizar eval, como en cierta medida sería de esperar.
Conclusiones
Se han visto cinco aproximaciones para iterar sobre arrays en Python. En esta comparativa se ha observado que las mejores aproximaciones para iterar en Python son NumExpr y pandas. Los métodos nativos de Python, como los bucles o iteradores son un orden de magnitud más lentos. Estos resultados se han de tener en cuenta sea necesario soluciones de cálculo numérico eficientes.
Imágenes: Pixabay (Free-Photos)
