虽然浮点运算的次数是相同的，但存取模式却完全不同，因此两者的运算根本无法比较，一般而言，矩阵对矩阵的运算总是比较快（就FLOPS而言）比矩阵-向量或向量-向量运算更有效，因为前者可以更好地利用高速缓存，从而使CPU的ALU得到近乎最佳的利用。在您的情况下，一方面，你必须读取一个n^3Tensor和两个n^2矩阵，所以内存占用根本不可比。
在内部，Tensor::contract在可能的情况下回退到Eigen的矩阵乘积内核，因此性能应该成对。

因为Tensor收缩和矩阵乘法不一样。
存在矩阵乘法的专用算法，如斯特拉森算法，减少了运算总数。此外，矩阵库多年来已得到高度优化，因此它们通常专用于使用矢量化指令（SIMD或AVX），具体取决于平台（Intel、AMD、ARM）。对于小尺寸或稀疏模式的矩阵，与非专用代码相比，速度增益巨大。
相比之下，Tensor库往往没有那么优化，所以如果你能把你的Tensor数学转换成矩阵代数，速度有很多机会会提高。

我可以用谷歌的基准测试程序重现这种缓慢的速度，正如我测试的那样，如果数据量很小，特征矩阵乘法比特征Tensor收缩更快，但结果是一样的。

所以我不确定后备计划
在内部，Tensor：：合同在可能的情况下回退到特征矩阵乘积内核，因此性能应该成对。
@ggael在这里提到。
下面是我的测试代码：

#include <Eigen/Dense>
#include <benchmark/benchmark.h>
#include <unsupported/Eigen/CXX11/Tensor>

constexpr std::size_t I = ;
constexpr std::size_t J = ;
constexpr std::size_t K = ;

static void bmForLoop(benchmark::State &state) {
  // Perform setup here
  Eigen::Matrix<double, I, J> m_0 = Eigen::Matrix<double, I, J>::Random();
  Eigen::Matrix<double, J, K> m_1 = Eigen::Matrix<double, J, K>::Random();
  Eigen::Matrix<double, I, K> m_2;

  for (auto _ : state) {
    // This code gets timed
    m_2 = Eigen::Matrix<double, I, K>::Zero();
    for (std::size_t i = 0; i < I; ++i) {
      for (std::size_t k = 0; k < K; ++k) {
        for (std::size_t j = 0; j < J; ++j) {
          benchmark::DoNotOptimize(m_2.coeffRef(i, k) +=
                                   m_0.coeff(i, j) * m_1.coeff(j, k));
        }
      }
    }
  }
}

static void bmEigenMatrix(benchmark::State &state) {
  // Perform setup here
  Eigen::Matrix<double, I, J> m_0 = Eigen::Matrix<double, I, J>::Random();
  Eigen::Matrix<double, J, K> m_1 = Eigen::Matrix<double, J, K>::Random();
  Eigen::Matrix<double, I, K> m_2;

  for (auto _ : state) {
    // This code gets timed
    benchmark::DoNotOptimize(m_2 = m_0 * m_1);
  }
}

static void bmEigenMatrixDynamic(benchmark::State &state) {
  // Perform setup here
  Eigen::MatrixXd m_0(I, J);
  m_0 = Eigen::Matrix<double, I, J>::Random();
  Eigen::MatrixXd m_1(J, K);
  m_1 = Eigen::Matrix<double, J, K>::Random();
  Eigen::MatrixXd m_2;

  for (auto _ : state) {
    // This code gets timed
    benchmark::DoNotOptimize(m_2 = m_0 * m_1);
  }
}

static void bmEigenTensorFixed(benchmark::State &state) {
  // Perform setup here
  Eigen::Matrix<double, I, J> m_0 = Eigen::Matrix<double, I, J>::Random();
  Eigen::Matrix<double, J, K> m_1 = Eigen::Matrix<double, J, K>::Random();
  Eigen::TensorMap<Eigen::TensorFixedSize<double, Eigen::Sizes<I, J>>> t_0(
      m_0.data(), I, J);
  Eigen::TensorMap<Eigen::TensorFixedSize<double, Eigen::Sizes<J, K>>> t_1(
      m_1.data(), J, K);
  Eigen::TensorFixedSize<double, Eigen::Sizes<I, K>> t_2;

  for (auto _ : state) {
    // This code gets timed
    benchmark::DoNotOptimize(
        t_2 = t_0.contract(
            t_1, Eigen::array<Eigen::IndexPair<Eigen::Index>, 1>{{{1, 0}}}));
  }
}

static void bmEigenTensor(benchmark::State &state) {
  // Perform setup here
  Eigen::Matrix<double, I, J> m_0 = Eigen::Matrix<double, I, J>::Random();
  Eigen::Matrix<double, J, K> m_1 = Eigen::Matrix<double, J, K>::Random();
  Eigen::TensorMap<Eigen::Tensor<double, 2>> t_0(m_0.data(), I, J);
  Eigen::TensorMap<Eigen::Tensor<double, 2>> t_1(m_1.data(), J, K);
  Eigen::Tensor<double, 2> t_2;

  for (auto _ : state) {
    // This code gets timed
    benchmark::DoNotOptimize(
        t_2 = t_0.contract(
            t_1, Eigen::array<Eigen::IndexPair<Eigen::Index>, 1>{{{1, 0}}}));
  }
}

BENCHMARK(bmForLoop);
BENCHMARK(bmEigenMatrix);
BENCHMARK(bmEigenMatrixDynamic);
BENCHMARK(bmEigenTensorFixed);
BENCHMARK(bmEigenTensor);
BENCHMARK_MAIN();

，其中I、J和K

constexpr std::size_t I = ;
constexpr std::size_t J = ;
constexpr std::size_t K = ;

用相同的数字填充，范围从1到8。
我用Bazel编译，编译命令是build --cxxopt=-std=c++17 --cxxopt=-march=native --cxxopt=-O3 --cxxopt=-DNDEBUG，Eigen的版本是3.4.0。