Question

我想迭代由-1和1组成的所有2 ^ 32行，并对每一行执行内积运算。有没有办法加快下面的代码？

import itertools
import operator

n = 16

survivors = []
for row in itertools.product([-1,1], repeat = 2*n):
    if (sum(map(operator.mul, row[0:n], row[n:2*n])) == 0):
        survivors.append(row)
print len(survivors)

Answer 1

这有点棘手，但是由-1和1组成的向量的内积可以转换为异或并计算由{组成的非零项向量{1}}和0 s。当然，1和0的32项向量的最佳容器是1。以下代码与您的建议相同，但运行它以uint32元素块为基础进行矢量化以获得速度

2**m

首先让我们根据您的代码检查正确性：

def bitwise_inner(n, m=12):
    bitmask = (1 << n) - 1
    m = min(m, 2*n)
    result = []
    chunk = 2**m
    for j in xrange(2**(2*n-m)):
        start = j * chunk
        items = np.arange(start, start+chunk, dtype=np.uint32)
        op = (items >> n) ^ (items & bitmask)
        # Keep only items with same number of 0s and 1s in the first n bits of op
        for k in xrange(n//2 - 1):
            # This removes a 1 from the binary representation of each number
            op &= op - 1
            mask = op != 0
            items = items[mask]
            op = op[mask]
        op &= op - 1
        result.append(items[op == 0])
    return sum([len(j) for j in result])

然后是一些时间：

def python_inner(n):
    survivors = []
    for row in itertools.product([-1,1], repeat = 2*n):
        if (sum(map(operator.mul, row[0:n], row[n:2*n])) == 0):
            survivors.append(row)
    return len(survivors)

In [2]: python_inner(8)
Out[2]: 17920

In [3]: bitwise_inner(8)
Out[3]: 17920

计算In [4]: %timeit python_inner(8) 1 loops, best of 3: 1.08 s per loop In [5]: %timeit bitwise_inner(8) 100 loops, best of 3: 3.35 ms per loop In [6]: %timeit bitwise_inner(12) 1 loops, best of 3: 1.07 s per loop的所有值仍然需要花费大量时间，但这仍然要快两个数量级。

如何加速大量内在产品

1 个答案: