Question

我在大型迭代中进行了以下两个矩阵代数计算。因此，我希望优化计算。

1：

    F = np.matrix(np.zeros(shape=(n+1,1)))
    F[0:n] = x - np.diag(np.array(theta)[0:n].flatten())*self.W*(theta[0:n]-self.m) + theta[0:n]*theta[n]
    F[n] = np.sum(theta[0:n]) - 1; #Lagrange multiplier term

2：

    J = np.matrix(np.zeros(shape=(n+1,n+1)))

    #Now add the dF_lamba/d(theta_i) = 1 and dF_lamba/d(lambda) = 0
    J[n,n] = 0

    #The following is correct for the off diagonal elements
    J[:n,:n] = -np.diag(np.array(theta)[0:n].flatten()) * self.W * np.diag(np.array(theta)[0:n].flatten())

    #We now update for the on diagonal elements
    J[:n,:n] = (J[:n,:n] - np.diag(np.diag(J[:n,:n])) +
           np.diag(np.array(-np.multiply(np.diag(np.diag(self.W)),np.diag(np.array(theta)[0:n].flatten())) * self.W * (theta[0:n] - self.m) + theta[n]).flatten()))

    #Finally adjust for the final columns
    J[:n,n] = theta[:n]
    J[n,:n] = 1

我不确定哪个numpy调用计算量很大。是否有可能在Python中优化它以接近C速度，或者我是否必须用C本身编程？

测试功能1

import numpy as np

def _nonLinEq(m, W, x, theta):
    #This outputs the nonlinear equations in theta
    #resulting from a the partial log derivative of a multivariate 
    #normal prior with covariance matrix E, means m and a multiinomial
    #likelihood with observations x.

    #F = [F_1, ... F_n, F_lambda]' ouput values where F_i = F(theta_i)
    n = len(m)
    F = define_F(n)
    F[0:n] = assign_values_to_F(x, theta, W, m, n)
    F[n] = assign_lagrange_multiplier_term(theta, n) #Lagrange multiplier term

    return F

def define_F(n):
    return np.matrix(np.zeros(shape=(n+1,1)))

def diag_theta(theta, n):
    return np.diag(np.array(theta)[0:n].flatten())

def multiply_terms(theta, W, m, n):
    return diag_theta(theta, n)*W*(theta[0:n]-m)

def assign_values_to_F(x,theta,W,m,n):
    return x - multiply_terms(theta, W, m, n) + theta[0:n]*theta[n]

def assign_lagrange_multiplier_term(theta, n):
    return np.sum(theta[0:n]) - 1 

def test_nonLinEq():
    n = 100
    temp = np.random.rand(n)
    m = np.transpose(np.matrix(temp/np.sum(temp)))
    W = np.matrix(np.diag(np.random.rand(n)))
    x = np.transpose(np.matrix(np.floor(np.random.rand(n)*10)))
    theta = np.transpose(np.matrix(np.append(np.ones(n)/n, -1)))

    for i in range(1000):
        _nonLinEq(m, W, x, theta)

2的测试功能

def _jacNLE(m, W, x, theta):
    #This finds the Jacobian of our non-linear equations

    #J = (J_ij) ouput values where F_ij = dF_i/d(theta_j)
    n = len(m);

    J = define_J(n)

    #The following is correct for the off diagonal elements
    diag_theta = convert_theta_to_diagonal(theta, n)
    J[:n,:n] = input_off_diagonal_J(diag_theta, W)

    #We now update for the on diagonal elements
    J[:n,:n] = remove_J_diagonal(J, n) + new_diagonal(W, theta, m, diag_theta, n)

    #Finally adjust for the final columns
    J[:n,n] = theta[:n]
    J[n,:n] = 1

    return J

def define_J(n):
    return np.matrix(np.zeros(shape=(n+1,n+1)))

def convert_theta_to_diagonal(theta, n):
    return np.diag(np.array(theta)[0:n].ravel())

def input_off_diagonal_J(diag_theta, W):
    return -diag_theta * W * diag_theta

def remove_J_diagonal(J, n):
    return J[:n,:n] - np.diag(np.diag(J[:n,:n]))

def matrix_prod(W, diag_theta):
    return -np.multiply(np.diag(np.diag(W)),diag_theta)

def new_diagonal(W, theta, m, diag_theta, n):
    return np.diag(np.array(matrix_prod(W, diag_theta) * W * (theta[0:n] - m) + theta[n]).ravel())

def test_jacNLE():
    n = 2
    temp = np.random.rand(n)
    m = np.transpose(np.matrix(temp/np.sum(temp)))
    W = np.matrix(np.diag(np.random.rand(n)))
    x = np.transpose(np.matrix(np.floor(np.random.rand(n)*10)))
    theta = np.transpose(np.matrix(np.append(np.ones(n)/n, -1)))

    for i in range(1000):
        _jacNLE(m, W, x, theta)

Answer 1

我最近想自己优化numpy代码。

首先我会尝试line_profiler package。它允许您测量每条线的时间消耗。起初使用起来有点棘手，但最后它是一个很好的工具，你可以肯定地发现瓶颈。

其他可能加快代码速度的工具是numba。如果您告诉某些类型信息，它会及时编译您的代码。

numpy中有特定的功能，我注意到它很慢。

首先：np.sum它＆＃39;奇怪但它甚至可能比内置sum - 函数的pythons慢。我曾试图通过将你想要总结的数组乘以matrix(ones(N)) *或者在＆＃34;中编写函数＆＃34;来避免它。 numba。我担心我不记得哪种解决方案更快。

我想我读过一次，np.matrix比简单的包装np.asmatrix慢。

如果您填写空数组，则可以使用np.empty代替np.zeros。

另一种方法是使用一些优化的BLAS，LAPACK东西再次在你的机器上编译numpy（直到我遇到了我从未听说过的那些问题......）它应该可以工作，但我失败了。

我也听说过ne gnumpy - 使用CUDA的套餐和你的GPU功能，但我不得不为此安装一些CUDA软件......

[编辑：] *我预定义onesN = matrix(ones(N))所以每次我只想总结数组时都不需要构建它。这实际上是另一个提示：寻找常数并预定义并仔细阅读它们......

Answer 2

我同意这些评论，你应该进行一些分析，但显然你可以做的一件事是分配

np.diag(np.array(theta)[0:n].flatten())

到一个局部变量并在你的计算中使用它，因为你多次这样做。如果你很大，这将是一个相当昂贵的计算，因为你是扁平化，复制到一个新的数组然后转而创建一个新的矩阵，该数组作为对角线。

Python / Numpy代码优化

2 个答案: