Question

我正在上大学参加数值分析课程。我们正在研究LU decomposition。在看到我的讲师之前，我尝试实施我的版本。我认为我的速度非常快，但实际上比较它们，即使它使用循环，我的讲师的版本也要快得多！那是为什么？

讲师版

def LU_decomposition(A):
    """Perform LU decomposition using the Doolittle factorisation."""

    L = np.zeros_like(A)
    U = np.zeros_like(A)
    N = np.size(A, 0)

    for k in range(N):
        L[k, k] = 1
        U[k, k] = (A[k, k] - np.dot(L[k, :k], U[:k, k])) / L[k, k]
        for j in range(k+1, N):
            U[k, j] = (A[k, j] - np.dot(L[k, :k], U[:k, j])) / L[k, k]
        for i in range(k+1, N):
            L[i, k] = (A[i, k] - np.dot(L[i, :k], U[:k, k])) / U[k, k]

    return L, U

我的版本

def lu(A, non_zero = 1):
    '''
    Given a matrix A, factorizes it into two matrices L and U, where L is
    lower triangular and U is upper triangular. This method implements
    Doolittle's method which sets l_ii = 1, i.e. L is a unit triangular
    matrix.

    :param      A: Matrix to be factorized. NxN
    :type       A: numpy.array

    :param non_zero: Value to which l_ii is assigned to. Must be non_zero.
    :type  non_zero: non-zero float.

    :return: (L, U)
    '''
    # Check if the matrix is square
    if A.shape[0] != A.shape[1]:
        return 'Input argument is not a square matrix.'

    # Store the size of the matrix
    n = A.shape[0]

    # Instantiate two zero matrices NxN (L, U)
    L = np.zeros((n,n), dtype = float)
    U = np.zeros((n,n), dtype = float)

    # Start algorithm
    for k in range(n):
        # Specify non-zero value for l_kk (Doolittle's)
        L[k, k] = non_zero
        # Case k = 0 is trivial
        if k == 0:
            # Complete first row of U
            U[0, :] = A[0, :] / L[0, 0]
            # Complete first column of L
            L[:, 0] = A[:, 0] / U[0, 0]
        # Case k = n-1 is trivial
        elif k == n-1:
            # Obtain  u_nn
            U[-1, -1] = (A[-1, -1] - np.dot(L[-1, :], U[:, -1])) / L[-1, -1]

        else:
            # Obtain u_kk
            U[k, k] = (A[k, k] - np.dot(L[k, :], U[:, k])) / L[k, k]
            # Complete kth row of U
            U[k, k+1:] = (A[k, k+1:] - [np.dot(L[k, :], U[:, i]) for i in \
                         range(k+1, n)]) / L[k, k]
            # Complete kth column of L
            L[k+1:, k] = (A[k+1:, k] - [np.dot(L[i, :], U[:, k]) for i in \
                         range(k+1, n)]) / U[k, k]
    return L, U

基准

我使用了以下命令：

A = np.random.randint(1, 10, size = (4,4))
%timeit lu(A)
57.5 µs ± 2.67 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit LU_decomposition(A)
42.1 µs ± 776 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

而且，scipy的版本怎么会好得多？

scipy.linalg.lu(A)
6.47 µs ± 219 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Answer 1

您的代码在python代码中有条件，而演示版本没有。 numpy库在本机代码中进行了高度优化，因此您可以采取任何措施将计算推入numpy而不是python，这将有助于提高速度。

Scipy必须在其库中有一个更优化的版本，看看它是如何进行单一调用来执行此操作，外部循环可能是优化本机代码的一部分，而不是相对较慢的python代码

你可以尝试使用Cython进行基准测试，看看更优化的python运行时有什么区别。

Answer 2

由于您使用的中间数据结构，我认为您的速度较慢：

使用[np.dot(L[k, :], U[:, i]) for i in range(k+1, n)]
使用A[k, k+1:] - temp_list
使用temp_ndarray / L[k, k]
最后，将此临时数组复制到结果数组

对于每个步骤，CPU必须执行循环，即使您没有明确地写一个循环。 Numpy将这些循环抽象出去，但它们仍然必须被执行！当然，通常在numpy而不是1个python循环中使用X隐式快速循环可以获得回报，但这仅适用于中型数组。此外，列表理解实际上只比常规for循环快一点。

scipy更快，因为它是低级别编程语言的高度优化实现（而python是一种非常高级的语言）。最后，这可能意味着你应该欣赏你的教授代码的优雅和可读性，而不是速度:)

为什么我教授的LU分解版本比我的快？ Python numpy

2 个答案: