比较Python，Numpy，Numba和C ++进行矩阵乘法

  • Z时代
  • 2024-01-10
  • 分类：问答

在我正在研究的程序中，我需要反复将两个矩阵相乘。由于其中一个矩阵的大小，此操作需要一些时间，我想看看哪种方法最有效。该矩阵具有维度(m x n)*(n x

p)其中m = n = 3和10^5 < p < 10^6。

除了Numpy（我认为它可以使用优化算法）之外，每个测试都由矩阵乘法的简单实现组成：

以下是我的各种实现：

def dot_py(A,B):
    m, n = A.shape
    p = B.shape[1]
    C = np.zeros((m,p))
    for i in range(0,m):
        for j in range(0,p):
            for k in range(0,n):
                C[i,j] += A[i,k]*B[k,j] 
    return C

def dot_np(A,B):
    C = np.dot(A,B)
    return C

该代码与Python相同，但是在使用之前及时进行了编译：

dot_nb = nb.jit(nb.float64[:,:](nb.float64[:,:], nb.float64[:,:]), nopython = True)(dot_py)

到目前为止，每个方法调用已使用该timeit模块计时10次​​。保持最佳结果。矩阵是使用创建的np.random.rand(n,m)。

mat2 dot(const mat2& m1, const mat2& m2)
{
    int m = m1.rows_;
    int n = m1.cols_;
    int p = m2.cols_;
    mat2 m3(m,p);
    for (int row = 0; row < m; row++) {
        for (int col = 0; col < p; col++) {
            for (int k = 0; k < n; k++) {
                m3.data_[p*row + col] += m1.data_[n*row + k]*m2.data_[p*k + col];
            }
        }
    }
    return m3;
}

这mat2是我定义的自定义类，并且dot(const mat2& m1, const mat2&

m2)是该类的朋友函数。它是使用定时QPF和QPC从Windows.h与程序使用的MinGW与编译后的g++命令。同样，保留从10次执行中获得的最佳时间。

不出所料，简单的Python代码速度较慢，但​​对于非常小的矩阵，它仍然胜过Numpy。在大多数情况下，Numba比Numpy快30％。

我对C 的结果感到惊讶，C 的结果比Numba花费了几乎一个数量级的时间。实际上，我希望这些过程花费相似的时间。

这引出了我的主要问题：这是否正常？如果不正常，为什么C 比Numba慢？我刚开始学习C

，所以我可能做错了什么。如果是这样，那是我的错误，或者我该怎么做才能提高代码效率（除了选择更好的算法之外）？

这是mat2该类的标题。

#ifndef MAT2_H
#define MAT2_H
#include <iostream>
class mat2
{
private:
    int rows_, cols_;
    float* data_;
public: 
    mat2() {}                                   // (default) constructor
    mat2(int rows, int cols, float value = 0);  // constructor
    mat2(const mat2& other);                    // copy constructor
    ~mat2();                                    // destructor
    // Operators
    mat2& operator=(mat2 other);                // assignment operator
    float operator()(int row, int col) const;
    float& operator() (int row, int col);
    mat2 operator*(const mat2& other);
    // Operations
    friend mat2 dot(const mat2& m1, const mat2& m2);
    // Other
    friend void swap(mat2& first, mat2& second);
    friend std::ostream& operator<<(std::ostream& os, const mat2& M);
};
#endif

正如许多人建议的那样，使用优化标志是匹配Numba的缺失元素。以下是与以前的曲线相比的新曲线。v2通过切换两个内部回路获得标记的曲线，并显示出另外30％至50％的改善。

回答：

绝对-O3用于优化。这将打开矢量化，这将大大加快代码的速度。

Numba应该已经做到了。

以上是 比较Python，Numpy，Numba和C ++进行矩阵乘法 的全部内容， 来源链接： utcz.com/qa/398962.html

回到顶部