我想计算 LeNet-5 ( paper) 的每一层需要多少触发器。一些论文总共给出了其他架构的 FLOPs(1，2，3)但是，这些论文没有详细说明如何计算 FLOPs 的数量，我不知道有多少 FLOPs 是必要的非线性激活函数。比如计算tanh(x)需要多少个FLOPs ？

我想这将是实现，也可能是特定于硬件的。但是，我主要对获得一个数量级感兴趣。我们是在谈论 10 个 FLOPs 吗？ 100 次失败？ 1000 次失败？因此，选择您想要的任何架构/实现作为答案。 (虽然我很欣赏接近“常见”设置的答案，比如 Intel i5/nvidia GPU/Tensorflow)

最佳答案

如果我们看一下 tanh(x) 的 glibc 实现，我们看到:

1. x值大于 22.0 和 double ，tanh(x)可以安全地假定为 1.0，因此几乎没有成本。
2. 对于非常小的x ，(假设 x<2^(-55) )另一个廉价的近似值是可能的: tanh(x)=x(1+x) , 所以只需要两个浮点运算。
3. 对于中间值，可以重写tanh(x)=(1-exp(-2x))/(1+exp(-2x)) .但是，必须准确，因为 1-exp(t)由于重要性的损失，对于小的 t 值是非常有问题的，所以使用 expm(x)=exp(x)-1并计算tanh(x)=-expm1(-2x)/(expm1(-2x)+2) .

所以基本上，最坏的情况大约是 expm1 所需操作次数的 2 倍。 ，这是一个相当复杂的函数。最好的方法可能只是测量计算 tanh(x) 所需的时间。与两个 double 的简单乘法所需的时间相比。

我在 Intel 处理器上的(草率的)实验产生了以下结果，这给出了一个粗略的想法:

因此对于非常小的数字>22 几乎没有成本，对于高达 0.1 的数字我们支付 6 FLOPS，然后每个 tanh 的成本上升到大约 20 FLOPS -计算。

关键要点:计算成本 tanh(x)取决于参数 x最大成本介于 10 到 100 FLOPs 之间。

有一个 Intel 指令叫做 F2XM1 计算2^x-1对于 -1.0<x<1.0 , 可用于计算 tanh ，至少在一定范围内。但是，如果 agner's tables可以相信，此操作的成本约为 60 FLOP。

另一个问题是矢量化——据我所知，普通的 glibc 实现没有矢量化。因此，如果您的程序使用矢量化并且必须使用未矢量化的 tanh实现它会进一步减慢程序。为此，英特尔编译器具有 mkl 库 vectorizes tanh 等等。

如您在表中所见，每次操作的最大成本约为 10 个时钟( float 操作的成本约为 1 个时钟)。

我猜你有机会通过使用 -ffast-math 赢得一些 FLOPs编译器选项，这会导致程序速度更快但精度较低(这是 Cuda 或 c/c++ 的一个选项，不确定是否可以为 python/numpy 完成)。

为图形生成数据的 c++ 代码(使用 g++ -std=c++11 -O2 编译)。它的目的不是给出确切的数字，而是对成本的第一印象:

#include <chrono>
#include <iostream>
#include <vector>
#include <math.h>

int main(){
   const std::vector<double> starts={1e-30, 1e-18, 1e-16, 1e-10, 1e-5, 1e-2, 1e-1, 0.5, 0.7, 0.9, 1.0, 2.0, 10, 20, 23, 100,1e3, 1e4};
   const double FACTOR=1.0+1e-11;
   const size_t ITER=100000000; 


   //warm-up:
   double res=1.0;
      for(size_t i=0;i<4*ITER;i++){
      res*=FACTOR;
   }
   //overhead:
   auto begin = std::chrono::high_resolution_clock::now();
   for(size_t i=0;i<ITER;i++){
      res*=FACTOR;
   }
   auto end = std::chrono::high_resolution_clock::now();
   auto overhead=std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count(); 
   //std::cout<<"overhead: "<<overhead<<"\n";


   //experiments:
   for(auto start : starts){
       begin=std::chrono::high_resolution_clock::now();
       for(size_t i=0;i<ITER;i++){
           res*=tanh(start);
           start*=FACTOR;
       }
       auto end = std::chrono::high_resolution_clock::now();
       auto time_needed=std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count();
       std::cout<<start<<" "<<time_needed/overhead<<"\n"; 
   }

   //overhead check:
   begin = std::chrono::high_resolution_clock::now();
   for(size_t i=0;i<ITER;i++){
      res*=FACTOR;
   }
   end = std::chrono::high_resolution_clock::now();
   auto overhead_new=std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count(); 
   std::cerr<<"overhead check: "<<overhead/overhead_new<<"\n";
   std::cerr<<res;//don't optimize anything out...
}

关于python - tanh 需要多少个 FLOP？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41251698/