Why list comprehension is much faster than numpy for multiplying arrays?

by

Creation of numpy arrays is much slower than creation of lists:

In [153]: %timeit a = [[2,3,5],[3,6,2],[1,3,2]]
1000000 loops, best of 3: 308 ns per loop

In [154]: %timeit a = np.array([[2,3,5],[3,6,2],[1,3,2]])
100000 loops, best of 3: 2.27 µs per loop

There can also fixed costs incurred by NumPy function calls before the meat
of the calculation can be performed by a fast underlying C/Fortran function. This can include ensuring the inputs are NumPy arrays,

These setup/fixed costs are something to keep in mind before assuming NumPy
solutions are inherently faster than pure-Python solutions. NumPy shines when
you set up large arrays once and then perform many fast NumPy operations
on the arrays. It may fail to outperform pure Python if the arrays are small
because the setup cost can outweigh the benefit of offloading the calculations
to compiled C/Fortran functions. For small arrays there simply may not be enough
calculations to make it worth it.

If you increase the size of the arrays a bit, and move creation of the arrays
into the setup, then NumPy can be much faster than pure Python:

import numpy as np
from timeit import timeit

N, M = 300, 300

a = np.random.randint(100, size=(N,M))
b = np.random.randint(100, size=(N,))

a2 = a.tolist()
b2 = b.tolist()

s1="""
[[m*n for n in second] for m, second in zip(b2,a2)]
"""

s2 = """
(a.T*b).T
"""

s3 = """
a*b[:,None]
"""

assert np.allclose([[m*n for n in second] for m, second in zip(b2,a2)], (a.T*b).T)
assert np.allclose([[m*n for n in second] for m, second in zip(b2,a2)], a*b[:,None])

print 's1: {:.4f}'.format(
    timeit(stmt=s1, number=10**3, setup='from __main__ import a2,b2'))
print 's2: {:.4f}'.format(
    timeit(stmt=s2, number=10**3, setup='from __main__ import a,b'))
print 's3: {:.4f}'.format(
    timeit(stmt=s3, number=10**3, setup='from __main__ import a,b'))

yields

s1: 4.6990
s2: 0.1224
s3: 0.1234

More Related Contents:

  1. Multiple matrix multiplication
  2. Most efficient way to map function over numpy array
  3. Are list-comprehensions and functional functions faster than “for loops”?
  4. Performance of Pandas apply vs np.vectorize to create new column from existing columns
  5. numpy: most efficient frequency counts for unique values in an array
  6. Why is numpy’s einsum faster than numpy’s built in functions?
  7. Numpy sum elements in array based on its value
  8. Efficiently return the index of the first value satisfying condition in array
  9. Implement MATLAB’s im2col ‘sliding’ in Python
  10. Frequency counts for unique values in a NumPy array
  11. Most efficient way to forward-fill NaN values in numpy array
  12. Python’s sum vs. NumPy’s numpy.sum
  13. Pandas pd.Series.isin performance with set versus array
  14. Numpy and line intersections
  15. Efficiently detect sign-changes in python
  16. Efficiently Calculating a Euclidean Distance Matrix Using Numpy
  17. Efficient way to take the minimum/maximum n values and indices from a matrix using NumPy
  18. Numpy vs Cython speed
  19. How to get faster code than numpy.dot for matrix multiplication?
  20. numpy float: 10x slower than builtin in arithmetic operations?
  21. How to get element-wise matrix multiplication (Hadamard product) in numpy?
  22. Flattening a list of NumPy arrays?
  23. Fastest save and load options for a numpy array
  24. No speedup when summing uint16 vs uint64 arrays with NumPy?
  25. Python Numpy Data Types Performance
  26. how to speed up a vector cross product calculation
  27. Getting days since last occurence in Pandas DataFrame?
  28. Creating a numpy array of 3D coordinates from three 1D arrays
  29. Split Python sequence (time series/array) into subsequences with overlap
  30. numpy faster than numba and cython , how to improve numba code

Leave a Comment