Numpy vs Eigen vs Xtensor 线性代数基准奇数

Question

我最近试图比较不同的 python 和 C++ 矩阵库的线性代数性能，以了解在即将到来的项目中使用哪些。 虽然有多种类型的线性代数运算，但我选择主要关注矩阵求逆，因为它似乎给出了奇怪的结果。 我在下面编写了以下代码进行比较，但我认为我一定做错了什么。

C++代码

    #include <iostream>
    #include "eigen/Eigen/Dense"
    #include <xtensor/xarray.hpp>
    #include <xtensor/xio.hpp>
    #include <xtensor/xview.hpp>
    #include <xtensor/xrandom.hpp>
    #include <xtensor-blas/xlinalg.hpp> //-lblas -llapack for cblas,   -llapack -L OpenBLAS/OpenBLAS_Install/lib -l:libopenblas.a -pthread for openblas

    //including accurate timer
    #include <chrono>
    //including vector array
    #include <vector>

    void basicMatrixComparisonEigen(std::vector<int> dims, int numrepeats = 1000);
    void basicMatrixComparisonXtensor(std::vector<int> dims, int numrepeats = 1000);
    
    int main()
    {
      std::vector<int> sizings{1, 10, 100, 1000, 10000, 100000};
    
      basicMatrixComparisonEigen(sizings, 2);
      basicMatrixComparisonXtensor(sizings,2);
      return 0;
    }
    
    
    void basicMatrixComparisonEigen(std::vector<int> dims, int numrepeats)
    {
      std::chrono::high_resolution_clock::time_point t1;
      std::chrono::high_resolution_clock::time_point t2;
      using time = std::chrono::high_resolution_clock;
    
      std::cout << "Timing Eigen: " << std::endl;
      for (auto &dim : dims)
      {
    
        std::cout << "Scale Factor: " << dim << std::endl;
        try
        {
          //Linear Operations
          auto l = Eigen::MatrixXd::Random(dim, dim);
    
          //Eigen Matrix inversion
          t1 = time::now();
          for (int i = 0; i < numrepeats; i++)
          {
            Eigen::MatrixXd pinv = l.completeOrthogonalDecomposition().pseudoInverse();
            //note this does not come out to be identity.  The inverse is wrong.
            //std::cout<<l*pinv<<std::endl;
          }
          t2 = time::now();
          std::cout << "Eigen Matrix inversion took: " << std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1).count() * 1000 / (double)numrepeats << " milliseconds." << std::endl;
          std::cout << "\n\n\n";
        }
        catch (const std::exception &e)
        {
          std::cout << "Error:   '" << e.what() << "'\n";
        }
      }
    }
    
    
    void basicMatrixComparisonXtensor(std::vector<int> dims, int numrepeats)
    {
      std::chrono::high_resolution_clock::time_point t1;
      std::chrono::high_resolution_clock::time_point t2;
      using time = std::chrono::high_resolution_clock;
    
      std::cout << "Timing Xtensor: " << std::endl;
      for (auto &dim : dims)
      {
    
        std::cout << "Scale Factor: " << dim << std::endl;
        try
        {
    
          //Linear Operations
          auto l = xt::random::randn<double>({dim, dim});
    
          //Xtensor Matrix inversion
          t1 = time::now();
          for (int i = 0; i < numrepeats; i++)
          {
            auto inverse = xt::linalg::pinv(l);
            //something is wrong here.  The inverse is not actually the inverse when you multiply it out. 
            //std::cout << xt::linalg::dot(inverse,l) << std::endl;
          }
          t2 = time::now();
          std::cout << "Xtensor Matrix inversion took: " << std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1).count() * 1000 / (double)numrepeats << " milliseconds." << std::endl;
        
          std::cout << "\n\n\n";
        }
        catch (const std::exception &e)
        {
          std::cout << "Error:   '" << e.what() << "'\n";
        }
      }
    }

这是编译的：

g++ cpp_library.cpp -O2  -llapack -L OpenBLAS/OpenBLAS_Install/lib -l:libopenblas.a -pthread -march=native -o benchmark.exe

对于 OpenBLAS，以及

g++ cpp_library.cpp -O2  -lblas -llapack -march=native -o benchmark.exe

对于 cBLAS。
g++ 版本 9.3.0。

对于 Python 3：

import numpy as np
from datetime import datetime as dt

#import timeit

start=dt.now()
l=np.random.rand(1000,1000)
for i in range(2):
    result=np.linalg.inv(l)
end=dt.now()
print("Completed in: "+str((end-start)/2))
#print(np.matmul(l,result))
#print(np.dot(l,result))
#Timeit also gives similar results

我将专注于在我的计算机上运行合理时间的最大十年：1000x1000。 我知道只有 2 次运行会引入一些差异，但我已经运行了更多次，结果大致与以下相同：

• 特征 3.3.9： 196.804 毫秒
• Xtensor/Xtensor-blas w/ OpenBlas： 378.156 毫秒
• Numpy 1.17.4： 172.582 毫秒

这是一个合理的预期结果吗？ 为什么 C++ 库比 Numpy 慢？ 所有 3 个软件包都使用某种 Lapack/BLAS 后端，但 3 个之间存在显着差异。特别是，Xtensor 将使用 OpenBlas 的线程将我的 CPU 固定到 100% 的使用率，但仍然设法获得更差的性能。

我想知道 C++ 库是否实际上正在执行矩阵的逆/伪逆，如果这是导致这些结果的原因。 在 C++ 测试代码的注释部分中，我注意到当我对 Eigen 和 Xtensor 的结果进行健全性检查时，矩阵与其逆矩阵之间的结果矩阵乘积甚至不接近单位矩阵。 我尝试使用较小的矩阵（10x10），认为这可能是一个精度错误，但问题仍然存在。 在另一个测试中，我测试秩，这些矩阵是满秩的。 为了确保我没有发疯，我在这两种情况下都尝试使用 inv() 而不是 pinv()，结果是一样的。 我是在这个线性代数基准测试中使用了错误的函数，还是这个 Numpy 在 2 个功能失调的低级库上扭曲了刀？

编辑：谢谢大家对这个问题的兴趣。 我想我已经弄清楚了这个问题。 我怀疑 Eigen 和 Xtensor 有惰性评估，这实际上导致下游错误，并输出随机矩阵而不是逆矩阵。 我能够通过代码中的以下替换来纠正奇怪的数字反转失败：

auto temp = Eigen::MatrixXd::Random(dim, dim);
Eigen::MatrixXd l(dim,dim);
l=temp;

和

auto temp = xt::random::randn<double>({dim, dim});
xt::xarray<double> l =temp;

但是，时间安排并没有太大变化：

• 特征 3.3.9： 201.386 毫秒
• Xtensor/Xtensor-blas w/ OpenBlas： 337.299 毫秒。
• Numpy 1.17.4：（从之前）172.582 毫秒

实际上，有点奇怪的是，添加 -O3 和 -ffast-math 实际上会稍微减慢代码速度。 -march=native 在我尝试时对我来说性能提升最大。 此外，对于这些问题，OpenBLAS 比 CBLAS 快 2-3 倍。

Answer 1

首先，您不是在计算相同的东西。

要计算 l 矩阵的逆矩阵，对 Eigen 使用 l.inverse()，对 xtensor 使用 xt::linalg::inv()

当您将 Blas 链接到 Eigen 或 xtensor 时，这些操作会自动分派给您选择的 Blas。

我尝试替换反函数，用 MatrixXd 和 xt::xtensor 替换 auto 以避免延迟评估，将 openblas 链接到 Eigen、xtensor 和 numpy 并仅使用 -O3 标志编译，以下是我的 Macbook pro M1 上的结果：

Eigen-3.3.9（使用 openblas） - ~ 38 ms

Eigen-3.3.9 (没有 openblas) - ~ 85 ms

xtensor-master（使用 openblas） - ~41 ms

Numpy- 1.21.2（使用 openblas） - ~35 ms。