Question

我试图计算numpy数组M的行列式，np.shape（M）=（N，L，L）就像这样：

import numpy as np

M = np.random.rand(1000*10*10).reshape(1000, 10, 10)
dm = np.zeros(1000)
for _ in xrange(len(dm)):
    dm[_] = np.linalg.det(M[_])

有没有循环的方法？ “N”比“L”大一些数量级。我想到了类似的东西：

np.apply_over_axes(np.linalg.det(M), axis=0)

有没有更快的方式做我想要的？我猜循环开销是一个性能瓶颈，因为小矩阵的行列式是一个相对便宜的操作（或者我错了？）。

Answer 1

您需要修改np.linalg.det才能获得速度。我的想法是det()是一个Python函数，它首先进行大量检查，并调用fortran例程，并进行一些数组计算以获得结果。

以下是来自numpy的代码：

def slogdet(a):
    a = asarray(a)
    _assertRank2(a)
    _assertSquareness(a)
    t, result_t = _commonType(a)
    a = _fastCopyAndTranspose(t, a)
    a = _to_native_byte_order(a)
    n = a.shape[0]
    if isComplexType(t):
        lapack_routine = lapack_lite.zgetrf
    else:
        lapack_routine = lapack_lite.dgetrf
    pivots = zeros((n,), fortran_int)
    results = lapack_routine(n, n, a, n, pivots, 0)
    info = results['info']
    if (info < 0):
        raise TypeError, "Illegal input to Fortran routine"
    elif (info > 0):
        return (t(0.0), _realType(t)(-Inf))
    sign = 1. - 2. * (add.reduce(pivots != arange(1, n + 1)) % 2)
    d = diagonal(a)
    absd = absolute(d)
    sign *= multiply.reduce(d / absd)
    log(absd, absd)
    logdet = add.reduce(absd, axis=-1)
    return sign, logdet

def det(a):
    sign, logdet = slogdet(a)
    return sign * exp(logdet)

要加速此功能，您可以省略检查（保持输入正确的责任），并在数组中收集fortran结果，并在没有for循环的情况下对所有小数组进行最终计算。

这是我的结果：

import numpy as np
from numpy.core import intc
from numpy.linalg import lapack_lite

N = 1000
M = np.random.rand(N*10*10).reshape(N, 10, 10)

def dets(a):
    length = a.shape[0]
    dm = np.zeros(length)
    for i in xrange(length):
        dm[i] = np.linalg.det(M[i])
    return dm

def dets_fast(a):
    m = a.shape[0]
    n = a.shape[1]
    lapack_routine = lapack_lite.dgetrf
    pivots = np.zeros((m, n), intc)
    flags = np.arange(1, n + 1).reshape(1, -1)
    for i in xrange(m):
        tmp = a[i]
        lapack_routine(n, n, tmp, n, pivots[i], 0)
    sign = 1. - 2. * (np.add.reduce(pivots != flags, axis=1) % 2)
    idx = np.arange(n)
    d = a[:, idx, idx]
    absd = np.absolute(d)
    sign *= np.multiply.reduce(d / absd, axis=1)
    np.log(absd, absd)
    logdet = np.add.reduce(absd, axis=-1)
    return sign * np.exp(logdet)

print np.allclose(dets(M), dets_fast(M.copy()))

，速度是：

timeit dets(M)
10 loops, best of 3: 159 ms per loop

timeit dets_fast(M)
100 loops, best of 3: 10.7 ms per loop

因此，通过这样做，您可以加速15次。没有任何编译代码，这是一个很好的结果。

注意：我省略了fortran例程的错误检查。

Answer 2

我无法使apply_over_axes工作，因为我认为这是一个3D数组。无论如何，分析代码表明程序在循环中花费的时间很少，

import cProfile
import pstats
N=10000
M = np.random.rand(N*10*10).reshape(N, 10, 10)
def f(M):
    dm = np.zeros(N)
    for _ in xrange(len(dm)):
        dm[_] = np.linalg.det(M[_])
    return dm
cProfile.run('f(M)','foo')
p = pstats.Stats('foo')
res = p.sort_stats('cumulative').print_stats(10)

结果是“0.955秒”的运行时间，在linalg.py:1642(det）中花费了0.930秒的累计时间。

如果我使用2x2矩阵执行相同的测试，我得到的总时间为.844s，而linalg.py:1642(det）得到.821s，尽管矩阵很小。然后，似乎det()函数对小矩阵的开销很大。

使用30x30，我的总时间为1.198秒，det()的时间为1.172。

使用70x70时，总计为3.122，det()中的时间为3.094，循环中的时间不到1％。

似乎在任何情况下，都不值得优化python循环。

多维数组的决定因素

2 个答案: