如何在python中加速多个内积答案

【问题标题】：How to speed up multiple inner products in python如何在python中加速多个内积
【发布时间】：2015-01-13 15:50:28
【问题描述】：

我有一些简单的代码可以执行以下操作。

它遍历所有可能长度为 n 的列表 F 和 +-1 个条目。对于每一个，它会遍历所有可能的长度 2n 列表 S 和 +-1 个条目，其中 $S$ 的前半部分只是后半部分的副本。该代码计算F 与长度为n 的每个S 子列表的内积。对于每个 F，S，它计算在第一个非零内积之前为零的内积。

这里是代码。

#!/usr/bin/python

from __future__ import division
import itertools
import operator
import math

n=14
m=n+1
def innerproduct(A, B):
    assert (len(A) == len(B))
    s = 0 
    for k in xrange(0,n):
        s+=A[k]*B[k]
    return s

leadingzerocounts = [0]*m
for S in itertools.product([-1,1], repeat = n):
    S1 = S + S
    for F in itertools.product([-1,1], repeat = n):
        i = 0
        while (i<m):
            ip = innerproduct(F, S1[i:i+n])
            if (ip == 0):
                leadingzerocounts[i] +=1
                i+=1
            else:
                break

print leadingzerocounts

n=14 的正确输出是

[56229888, 23557248, 9903104, 4160640, 1758240, 755392, 344800, 172320, 101312, 75776, 65696, 61216, 59200, 59200, 59200]

使用 pypy，对于 n = 14，这需要 1 分 18 秒。不幸的是，我真的很想运行 16、18、20、22、24、26。我不介意使用 numba 或 cython，但如果可能的话，我想靠近 python。

非常感谢任何帮助加快这一进程。

我会在这里记录最快的解决方案。（如果我错过了更新的答案，请告诉我。）

n = 22，时间为 9 分 35.081 秒，由 Eisenstat (C) 得出
n = 18 在 1m16.344s 由 Eisenstat (pypy) 提供
n = 18 在 2m54.998s 由 Tupteq (pypy) 提供
n = 14 at 26s by Neil (numpy)
n - 14 在 11m59.192s by kslote1 (pypy)

【问题讨论】：

你试过使用 Numpy 多维数组吗？
可能没有机会添加代码，但请注意IP(A,B) = IP(A[:n/2 + 1], B[:n/2 + 1]) + IP(A[n/2 + 1:], B[n/2 + 1:]) 允许基于subset sum 使用的类似技术进行一些改进。这应该允许O(2^N) 算法而不是O(2^(2N))，尽管它可能需要O(2^N) 空间。这利用查找大小为N/2（其中有O(2^N))）对的所有IP，然后使用它来构建解决方案集。可以使用图表来处理在while循环中找到的状态转换。
经过一番测试，上面的方法可能不太实用。处理状态转换的问题似乎需要分支，这会引入先前已消除的数字以及重复的数字。基本上，我写的算法给出了第二个（i = 2及以上）之后的错误计数，并且简单地删除重复项并不足以修复它，尽管它有很大帮助，这表明这种方法可能存在缺陷，就获得 O( 2^N) 空间/时间性能。
@Nuclearman 我不得不承认这令人惊讶。
无论如何，您都可以自己尝试。 IP 匹配部分非常简单，并且对于获得第一个计数非常快。这是我无法正确处理班次的批处理，如果可能的话，我会质疑。我可能不会尝试实现算法的正确解决方案，因为没有它是 O(2^N)，我认为这不太可能，它很有可能不会比 David Eisenstat 的答案更好。

标签： python performance algorithm cython numba

【解决方案1】：

一个非常简单的 n 因子加速是更改此代码：

def innerproduct(A, B):
    assert (len(A) == len(B))
    for j in xrange(len(A)):
        s = 0 
        for k in xrange(0,n):
            s+=A[k]*B[k]
    return s

到

def innerproduct(A, B):
    assert (len(A) == len(B))
    s = 0 
    for k in xrange(0,n):
        s+=A[k]*B[k]
    return s

（我不知道你为什么要对 j 进行循环，但它每次都进行相同的计算，所以没有必要。）

【讨论】：

谢谢，这只是一个错误！你回答得这么快，如果你不介意，我就解决这个问题。

【解决方案2】：

我已经尝试将其转移到 NumPy 数组中并从这个问题中借用：itertools product speed up

这就是我得到的，（这里可能有更多的加速）：

def find_leading_zeros(n):
    if n % 2:
        return numpy.zeros(n)
    m = n+1
    leading_zero_counts = numpy.zeros(m)
    product_list = [-1, 1]
    repeat = n
    s = (numpy.array(product_list)[numpy.rollaxis(numpy.indices((len(product_list),) * repeat),
                                                  0, repeat + 1).reshape(-1, repeat)]).astype('int8')
    i = 0
    size = s.shape[0] / 2
    products = numpy.zeros((size, size), dtype=bool)
    while i < m:
        products += (numpy.tensordot(s[0:size, 0:size],
                                     numpy.roll(s, i, axis=1)[0:size, 0:size],
                                     axes=(-1,-1))).astype('bool')
        leading_zero_counts[i] = (products.size - numpy.sum(products)) * 4
        i += 1

    return leading_zero_counts

运行 n=14 我得到：

>>> find_leading_zeros(14)
array([ 56229888.,  23557248.,   9903104.,   4160640.,   1758240.,
        755392.,    344800.,    172320.,    101312.,     75776.,
        65696.,     61216.,     59200.,     59200.,     59200.])

所以一切看起来都很好。至于速度：

>>> timeit.timeit("find_leading_zeros_old(10)", number=10)
28.775046825408936
>>> timeit.timeit("find_leading_zeros(10)", number=10)
2.236745834350586

看看你的想法。

编辑：

原始版本在 N=14 时使用了 2074MB 内存，因此我删除了串联数组并改用 numpy.roll。还将数据类型更改为使用布尔数组，在 n=14 时将内存降至 277MB。

时间明智的编辑又快了一点：

>>> timeit.timeit("find_leading_zeros(10)", number=10)
1.3816070556640625

EDIT2：

好的，正如大卫指出的那样，添加对称性，我再次减少它。它现在使用 213MB。与以前的编辑相比的比较时间：

>>> timeit.timeit("find_leading_zeros(10)", number=10)
0.35357093811035156

我现在可以在我的 mac 书上在 14 秒内完成 n=14 的案例，我认为这对于“纯 python”来说还不错。

【讨论】：

很遗憾，您的解决方案在 n=14 时占用了太多 RAM，我无法测试。

【解决方案3】：

这个新代码利用问题的循环对称性获得了另一个数量级的加速。这个 Python 版本使用 Duval 算法枚举项链； C 版本使用蛮力。两者都包含下面描述的加速。 在我的机器上，C 版本在 100 秒内解决了 n = 20！ 粗略的计算表明，如果你让它在单核上运行一周，它可以做到 n = 26，并且如下所述，它适合并行性。

import itertools


def necklaces_with_multiplicity(n):
    assert isinstance(n, int)
    assert n > 0
    w = [1] * n
    i = 1
    while True:
        if n % i == 0:
            s = sum(w)
            if s > 0:
                yield (tuple(w), i * 2)
            elif s == 0:
                yield (tuple(w), i)
        i = n - 1
        while w[i] == -1:
            if i == 0:
                return
            i -= 1
        w[i] = -1
        i += 1
        for j in range(n - i):
            w[i + j] = w[j]


def leading_zero_counts(n):
    assert isinstance(n, int)
    assert n > 0
    assert n % 2 == 0
    counts = [0] * n
    necklaces = list(necklaces_with_multiplicity(n))
    for combo in itertools.combinations(range(n - 1), n // 2):
        for v, multiplicity in necklaces:
            w = list(v)
            for j in combo:
                w[j] *= -1
            for i in range(n):
                counts[i] += multiplicity * 2
                product = 0
                for j in range(n):
                    product += v[j - (i + 1)] * w[j]
                if product != 0:
                    break
    return counts


if __name__ == '__main__':
    print(leading_zero_counts(12))

C 版：

#include <stdio.h>

enum {
  N = 14
};

struct Necklace {
  unsigned int v;
  int multiplicity;
};

static struct Necklace g_necklace[1 << (N - 1)];
static int g_necklace_count;

static void initialize_necklace(void) {
  g_necklace_count = 0;
  for (unsigned int v = 0; v < (1U << (N - 1)); v++) {
    int multiplicity;
    unsigned int w = v;
    for (multiplicity = 2; multiplicity < 2 * N; multiplicity += 2) {
      w = ((w & 1) << (N - 1)) | (w >> 1);
      unsigned int x = w ^ ((1U << N) - 1);
      if (w < v || x < v) goto nope;
      if (w == v || x == v) break;
    }
    g_necklace[g_necklace_count].v = v;
    g_necklace[g_necklace_count].multiplicity = multiplicity;
    g_necklace_count++;
   nope:
    ;
  }
}

int main(void) {
  initialize_necklace();
  long long leading_zero_count[N + 1];
  for (int i = 0; i < N + 1; i++) leading_zero_count[i] = 0;
  for (unsigned int v_xor_w = 0; v_xor_w < (1U << (N - 1)); v_xor_w++) {
    if (__builtin_popcount(v_xor_w) != N / 2) continue;
    for (int k = 0; k < g_necklace_count; k++) {
      unsigned int v = g_necklace[k].v;
      unsigned int w = v ^ v_xor_w;
      for (int i = 0; i < N + 1; i++) {
        leading_zero_count[i] += g_necklace[k].multiplicity;
        w = ((w & 1) << (N - 1)) | (w >> 1);
        if (__builtin_popcount(v ^ w) != N / 2) break;
      }
    }
  }
  for (int i = 0; i < N + 1; i++) {
    printf(" %lld", 2 * leading_zero_count[i]);
  }
  putchar('\n');
  return 0;
}

您可以通过利用符号对称性 (4x) 并仅迭代那些通过第一个内积测试的向量（渐近地，O(sqrt(n))x）来获得一点加速。

import itertools


n = 10
m = n + 1


def innerproduct(A, B):
    s = 0
    for k in range(n):
        s += A[k] * B[k]
    return s


leadingzerocounts = [0] * m
for S in itertools.product([-1, 1], repeat=n - 1):
    S1 = S + (1,)
    S1S1 = S1 * 2
    for C in itertools.combinations(range(n - 1), n // 2):
        F = list(S1)
        for i in C:
            F[i] *= -1
        leadingzerocounts[0] += 4
        for i in range(1, m):
            if innerproduct(F, S1S1[i:i + n]):
                break
            leadingzerocounts[i] += 4
print(leadingzerocounts)

C 版本，以了解我们在 PyPy 中损失了多少性能（PyPy 的 16 大致相当于 C 的 18）：

#include <stdio.h>

enum {
  HALFN = 9,
  N = 2 * HALFN
};

int main(void) {
  long long lzc[N + 1];
  for (int i = 0; i < N + 1; i++) lzc[i] = 0;
  unsigned int xor = 1 << (N - 1);
  while (xor-- > 0) {
    if (__builtin_popcount(xor) != HALFN) continue;
    unsigned int s = 1 << (N - 1);
    while (s-- > 0) {
      lzc[0]++;
      unsigned int f = xor ^ s;
      for (int i = 1; i < N + 1; i++) {
        f = ((f & 1) << (N - 1)) | (f >> 1);
        if (__builtin_popcount(f ^ s) != HALFN) break;
        lzc[i]++;
      }
    }
  }
  for (int i = 0; i < N + 1; i++) printf(" %lld", 4 * lzc[i]);
  putchar('\n');
  return 0;
}

这个算法是令人尴尬的并行，因为它只是累加xor 的所有值。对于 C 版本，粗略计算表明，几千小时的 CPU 时间足以计算 n = 26，以 EC2 上的当前费率计算，这相当于几百美元。毫无疑问，需要进行一些优化（例如向量化），但对于这样的一次性优化，我不确定程序员需要付出多少努力。

【讨论】：

谢谢你确实加快了速度。用你的方法我最多可以达到 n=16。
我不得不承认我不明白为什么这个答案没有得到更多的支持。 SO 有时是个谜。
@user2179021 别担心。写这个答案我很开心。

【解决方案4】：

我试图加快速度，但我失败了:( 但我正在发送代码，它在某种程度上更快，但对于像n=24 这样的值来说还不够快。

我的假设

您的列表由值组成，因此我决定使用数字而不是列表 - 每个位代表一个可能的值：如果设置了位，则表示1，如果为零则表示-1。乘法{-1, 1} 唯一可能的结果是1 或-1，所以我使用按位XOR 而不是乘法。我还注意到存在对称性，因此您只需检查可能列表的子集（四分之一）并将结果乘以 4（大卫在他的回答中对此进行了解释）。

最后，我将可能操作的结果放到表格中，以消除计算的需要。这需要大量内存，但谁在乎（n=24 大约是 150MB）？

然后@David Eisenstat 回答了这个问题 :) 所以，我把他的代码修改为基于位的。它快了大约 2-3 倍（n=16 大约需要 30 秒，而 David 的解决方案大约需要 90 秒），但我认为这仍然不足以获得n=26 左右的结果。

import itertools

n = 16
m = n + 1
mask = (2 ** n) - 1

# Create table of sum results (replaces innerproduct())
tab = []
for a in range(2 ** n):
    s = 0
    for k in range(n):
        s += -1 if a & 1 else 1
        a >>= 1
    tab.append(s)

# Create combination bit masks for combinations
comb = []
for C in itertools.combinations(range(n - 1), n // 2):
    xor = 0
    for i in C:
       xor |= (1 << i)
    comb.append(xor)

leadingzerocounts = [0] * m
for S in xrange(2 ** (n-1)):
    S1 = S + (1 << (n-1))
    S1S1 = S1 + (S1 << n)

    for xor in comb:
        F = S1 ^ xor

        leadingzerocounts[0] += 4
        for i in range(1, m):
            if tab[F ^ ((S1S1 >> i) & mask)]:
                break
            leadingzerocounts[i] += 4

print(leadingzerocounts)

结论

我以为我发明了一些很棒的东西，并希望所有这些乱七八糟的东西都能极大地提高速度，但这种提升小得令人失望:(

我认为原因是 Python 使用运算符的方式 - 它为每个算术（或逻辑）操作调用函数，即使它可以通过单个汇编程序命令完成（我希望 pypy 能够将操作简化为水平，但它没有）。因此，如果将 C（或 ASM）与这种位操作解决方案一起使用，它可能会表现出色（也许您可以访问 n=24）。

【讨论】：

一直下降到 C 并没有太大的额外影响（请参阅我的编辑）。问题在于，每当 n 增加 2 时，工作量就会增加大约 16 倍。
因此，使用 C 代码可以走得更远。也许到 n=22 或 24。
在 pypy 和您的代码的帮助下，我设法做到了 n = 18。谢谢。

【解决方案5】：

在我看来，提高性能的一个好方法是使用 python 内置函数。

先用map计算条目的乘积：

>>> a =[1,2,3]
>>> b = [4,5,6]
>>>map(lambda x,y : x*y, a , b)
[4, 10, 18]

然后使用reduce 计算总和：

>>> reduce(lambda v,w: v+w, map(lambda x,y :x*y, a, b))
32

那么你的函数就变成了

def innerproduct(A, B):
    assert (len(A) == len(B))
    return reduce(lambda v,w: v+w, map(lambda x,y :x*y, A, B))

接下来，我们可以取出所有这些“for 循环”并用生成器替换它们并捕获 StopIteration。

#!/usr/bin/python

from __future__ import division
import itertools
import operator
import math

n=14
m=n+1
def innerproduct(A, B):
    assert (len(A) == len(B))
    return reduce(lambda v,w: v+w, map(lambda x,y :x*y, A, B))


leadingzerocounts = [0]*m

S_gen = itertools.product([-1,1], repeat = n)

try:
    while(True):
       S = S_gen.next()
       S1 = S + S
       F_gen = itertools.product([-1,1], repeat = n)
       try:
           while(True):
               F = F_gen.next()
               for i in xrange(m):
                   ip = innerproduct(F, S1[i:i+n])
                   if (ip == 0):
                       leadingzerocounts[i] +=1
                       i+=1
                   else:
                      break
       except StopIteration:
           pass

except StopIteration as e:
    print e

print leadingzerocounts

我观察到较小的 n 会加速，但我的 jalopy 缺乏计算我的版本的马力，也没有 n=14 的原始代码。进一步加快速度的一种方法是记住这一行：

    F_gen = itertools.product([-1,1], repeat = n)

【讨论】：

谢谢。不幸的是，正如您所建议的那样，您的代码对于 n = 14 来说非常慢。