Python: Vectorizing evaluations of arrays of lambda functions

Alright guys, I have an answer: numpy's vectorize.

Please read the edited section though. You'll discover that python actually optimizes code for you, which actually defeats the purpose of using numpy arrays in this case. (But using numpy arrays does not decrease the performance.)

The last test really shows is that python lists are as efficient as they could be, and so this vectorization procedure is unnecessary. This is why I didn't mark this question as the "best answer".

Setup code:

def factory(i): return lambda num: num==i

array1 = list()
for i in range(10000): array1.append(factory(i))
array1 = np.array(array1)
array2 = np.array(xrange(10000))

The "unvectorized" version:

def evaluate(array1, array2):
    return [func(val) for func, val in zip(array1, array2)]

%timeit evaluate(array1, array2)
# 100 loops, best of 3: 10 ms per loop

The vectorized version

def evaluate2(func, b): return func(b)
vec_evaluate = np.vectorize(evaluate2)
vec_evaluate(array1, array2)
# 100 loops, best of 3: 2.65 ms per loop

EDIT

Okay, I just wanted to paste more benchmarks that I received using the above tests, except with different test cases.

I made a third edit, showing what happens if you simply use python lists. The long story short, you actually won't regret much. This test case is on the very bottom.

Test cases only involving integers

In summary, if n is small, then the unvectorized version is better. Otherwise, vectorized is the way to go.

With n = 30

%timeit evaluate(array1, array2)
# 10000 loops, best of 3: 35.7 µs per loop
%timeit vec_evaluate(array1, array2)
# 10000 loops, best of 3: 27.6 µs per loop

With n = 7

%timeit evaluate(array1, array2)
100000 loops, best of 3: 9.93 µs per loop
%timeit vec_evaluate(array1, array2)
10000 loops, best of 3: 21.6 µs per loop

Test cases involving strings

Vectorization wins.

Setup code:

def factory(i): return lambda num: str(num)==str(i)

array1 = list()
for i in range(7):
    array1.append(factory(i))
array1 = np.array(array1)
array2 = np.array(xrange(7))

With n = 10000

%timeit evaluate(array1, array2)
10 loops, best of 3: 36.7 ms per loop

%timeit vec_evaluate(array1, array2)
100 loops, best of 3: 6.57 ms per loop

With n = 7

%timeit evaluate(array1, array2)
10000 loops, best of 3: 28.3 µs per loop

%timeit vec_evaluate(array1, array2)
10000 loops, best of 3: 27.5 µs per loop

Random tests

Just to see how branch prediction played a role. From what I'm seeing, it didn't really change much. Vectorization still usually wins.

Setup code.

def factory(i):
    if random() < 0.5:
        return lambda num: str(num) == str(i)
    return lambda num: num == i

When n = 10000

%timeit evaluate(array1, array2)
10 loops, best of 3: 25.7 ms per loop

%timeit vec_evaluate(array1, array2)
100 loops, best of 3: 4.67 ms per loop

When n = 7

%timeit evaluate(array1, array2)
10000 loops, best of 3: 23.1 µs per loop

%timeit vec_evaluate(array1, array2)
10000 loops, best of 3: 23.1 µs per loop

Using python lists instead of numpy arrays

I ran this test to see what happened when I chose not to use the "optimized" numpy arrays, and I received some very surprising results.

The setup code is almost the same, except I'm choosing not to use numpy arrays. I'm also doing this test for only the "random" case.

def factory(i):
    if random() < 0.5:
        return lambda num: str(num) == str(i)
    return lambda num: num == i


array1 = list()
for i in range(10000): array1.append(factory(i))
array2 = range(10000)

And the "unvectorized" version:

%timeit evaluate(array1, array2)
100 loops, best of 3: 4.93 ms per loop

You could see this is actually pretty surprising, because this is almost the same benchmark I was receiving with my random test case involving the vectorized evaluate.

%timeit vec_evaluate(array1, array2)
10 loops, best of 3: 19.8 ms per loop

Likewise, if you change these into numpy arrays before using vec_evaluate, you get the same 4.5 ms benchmark.