Skip to main content
 首页 » 编程设计

Python/Numpy 代码优化

2025年05月04日12lautakyan007

我在一次大迭代中有以下两个矩阵代数计算。因此,我希望优化计算。

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) 

请您参考如下方法:

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

起初我会尝试 line_profiler package .它允许您测量每行的时间消耗。起初使用看起来有点棘手,但最终它是一个很好的工具,您可以确定地检测到瓶颈。

可能会加速您的代码的其他工具是 numba .如果您提供一些类型信息,它会即时编译您的代码。

我注意到 numpy 中的某些特定函数速度很慢。

首先:np.sum 这很奇怪,但它甚至可以比 python 内置的 sum 函数慢。我曾经试图通过将要求和的数组与 matrix(ones(N))* 相乘或在 numba 中编写函数来避免它。恐怕我不记得哪个解决方案更快。

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

如果无论如何填充一个空数组,您可以使用 np.empty 而不是 np.zeros。

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

我还听说过 ne gnumpy-Package using CUDA 和您的 GPU 能力,但我必须为此安装一些 CUDA 软件...

[EDIT:] * 我预定义了 onesN = matrix(ones(N)) 这样我就不必每次都构建它只是想总结一个大批。这实际上是另一个提示:寻找常量并预定义和细读它们......