【发布时间】：2012-05-30 17:09:06
【问题描述】：
【问题讨论】：
【发布时间】：2012-05-30 17:09:06
【问题描述】：
试试这个 .NET Core 5+ 实现
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe float FastSigmoid(float v)
{
const float c1 = 0.03138777F;
const float c2 = 0.276281267F;
const float c_log2f = 1.442695022F;
v *= c_log2f;
int intPart = (int)v;
float x = (v - intPart);
float xx = x * x;
float v1 = c_log2f + c2 * xx;
float v2 = x + xx * c1 * x;
float v3 = (v2 + v1);
*((int*)&v3) += intPart << 24;
float v4 = v2 - v1;
float res = v3 / (v3 - v4); //for tanh change to (v3 + v4)/ (v3 - v4)
return res;
}
【讨论】：
你也可以这样用：
y=x / (2 * ((x<0.0)*-x+(x>=0.0)*x) + 2) + 0.5;
y'=y(1-y);
现在就像一个 sigmoid，因为 y(1-y)=y' 比 1/(2 (1 + abs(x))^2) 行为更像是快速 sigmoid；
【讨论】：
您可以使用两个公式来使用一个简单但有效的方法：
if x < 0 then f(x) = 1 / (0.5/(1+(x^2)))
if x > 0 then f(x) = 1 / (-0.5/(1+(x^2)))+1
这将如下所示：
Two graphs for a sigmoid {Blue: (0.5/(1+(x^2))), Yellow: (-0.5/(1+(x^2)))+1}
【讨论】：
为了让神经网络更灵活，通常使用一些阿尔法率来改变图形在 0 左右的角度。
sigmoid 函数如下所示：
f(x) = 1 / ( 1+exp(-x*alpha))
几乎等价的（但更快的功能）是：
f(x) = 0.5 * (x * alpha / (1 + abs(x*alpha))) + 0.5
您可以查看图表here
当我使用 abs 功能时，网络会变得快 100 倍以上。
【讨论】：
-
第二个等式中第一个圆括号应该在哪里结束？
-
固定，见内联。
tanh 函数可能在某些语言中进行了优化，使其比自定义定义的 x/(1+abs(x)) 更快，例如 Julia。
【讨论】：
您也可以使用粗略版本的 sigmoid（与原始版本的差异不超过 0.2%）：
inline float RoughSigmoid(float value)
{
float x = ::abs(value);
float x2 = x*x;
float e = 1.0f + x + x2*0.555f + x2*x2*0.143f;
return 1.0f / (1.0f + (value > 0 ? 1.0f / e : e));
}
void RoughSigmoid(const float * src, size_t size, const float * slope, float * dst)
{
float s = slope[0];
for (size_t i = 0; i < size; ++i)
dst[i] = RoughSigmoid(src[i] * s);
}
使用 SSE 优化 RoughSigmoid 函数：
#include <xmmintrin.h>
void RoughSigmoid(const float * src, size_t size, const float * slope, float * dst)
{
size_t alignedSize = size/4*4;
__m128 _slope = _mm_set1_ps(*slope);
__m128 _0 = _mm_set1_ps(-0.0f);
__m128 _1 = _mm_set1_ps(1.0f);
__m128 _0555 = _mm_set1_ps(0.555f);
__m128 _0143 = _mm_set1_ps(0.143f);
size_t i = 0;
for (; i < alignedSize; i += 4)
{
__m128 _src = _mm_loadu_ps(src + i);
__m128 x = _mm_andnot_ps(_0, _mm_mul_ps(_src, _slope));
__m128 x2 = _mm_mul_ps(x, x);
__m128 x4 = _mm_mul_ps(x2, x2);
__m128 series = _mm_add_ps(_mm_add_ps(_1, x), _mm_add_ps(_mm_mul_ps(x2, _0555), _mm_mul_ps(x4, _0143)));
__m128 mask = _mm_cmpgt_ps(_src, _0);
__m128 exp = _mm_or_ps(_mm_and_ps(_mm_rcp_ps(series), mask), _mm_andnot_ps(mask, series));
__m128 sigmoid = _mm_rcp_ps(_mm_add_ps(_1, exp));
_mm_storeu_ps(dst + i, sigmoid);
}
for (; i < size; ++i)
dst[i] = RoughSigmoid(src[i] * slope[0]);
}
使用 AVX 优化 RoughSigmoid 函数：
#include <immintrin.h>
void RoughSigmoid(const float * src, size_t size, const float * slope, float * dst)
{
size_t alignedSize = size/8*8;
__m256 _slope = _mm256_set1_ps(*slope);
__m256 _0 = _mm256_set1_ps(-0.0f);
__m256 _1 = _mm256_set1_ps(1.0f);
__m256 _0555 = _mm256_set1_ps(0.555f);
__m256 _0143 = _mm256_set1_ps(0.143f);
size_t i = 0;
for (; i < alignedSize; i += 8)
{
__m256 _src = _mm256_loadu_ps(src + i);
__m256 x = _mm256_andnot_ps(_0, _mm256_mul_ps(_src, _slope));
__m256 x2 = _mm256_mul_ps(x, x);
__m256 x4 = _mm256_mul_ps(x2, x2);
__m256 series = _mm256_add_ps(_mm256_add_ps(_1, x), _mm256_add_ps(_mm256_mul_ps(x2, _0555), _mm256_mul_ps(x4, _0143)));
__m256 mask = _mm256_cmp_ps(_src, _0, _CMP_GT_OS);
__m256 exp = _mm256_or_ps(_mm256_and_ps(_mm256_rcp_ps(series), mask), _mm256_andnot_ps(mask, series));
__m256 sigmoid = _mm256_rcp_ps(_mm256_add_ps(_1, exp));
_mm256_storeu_ps(dst + i, sigmoid);
}
for (; i < size; ++i)
dst[i] = RoughSigmoid(src[i] * slope[0]);
}
【讨论】：
-
我们在这里倾斜什么？函数的典型输入是什么
这里的人们主要关心一个函数相对于另一个函数有多快，并创建微基准来查看f1(x) 的运行速度是否比f2(x) 快0.0001 毫秒。最大的问题是，这几乎是无关紧要的，因为重要的是你的网络用你的激活函数学习的速度有多快，试图最小化你的成本函数。
按照目前的理论，rectifier function and softplus
与 sigmoid 函数或类似的激活函数相比，允许 用于更快、更有效地训练深度神经架构 大而复杂的数据集。
所以我建议扔掉微优化，看看哪个函数可以更快地学习（同时看看其他各种成本函数）。
【讨论】：
-
优化训练网络的执行（例如在没有浮点单元的微控制器上）和优化学习速度（学习算法）是两个不同的问题。如果您想在给定的有限硬件上增加神经元，或者如果您想减少执行时的能耗，则必须优化计算时间/空间复杂度。
使用 Eureqa 搜索 sigmoid 的近似值，我发现 1/(1 + 0.3678749025^x) 近似它。它非常接近，只需用 x 的否定来摆脱一个操作。
这里显示的其他一些功能很有趣，但是电源操作真的那么慢吗？我测试了它，它实际上比加法更快，但这可能只是侥幸。如果是这样，它应该和所有其他的一样快或更快。
编辑：0.5 + 0.5*tanh(0.5*x) 和不太准确，0.5 + 0.5*tanh(n) 也有效。如果您不关心在范围 [0,1] 之间（如 sigmoid），您可以摆脱常量。但它假设 tanh 更快。
【讨论】：
-
幂项执行起来通常很慢，是的，因此这个近似值并不能避免原始问题的那个方面，因为 pow() 通常会在 CPU 电路中实现，作为对 exp( ) 执行/评估。
这个答案可能与大多数情况无关，但只是想指出，对于 CUDA 计算，我发现 x/sqrt(1+x^2) 是迄今为止最快的函数。
例如，使用单精度浮点内在函数完成：
__device__ void fooCudaKernel(/* some arguments */) {
float foo, sigmoid;
// some code defining foo
sigmoid = __fmul_rz(rsqrtf(__fmaf_rz(foo,foo,1)),foo);
}
【讨论】：
-
好。虽然只有当您将神经元计算为完全连接的矩阵而不是单行/稀疏矩阵的向量时才会这样。
最好先在您的硬件上进行测量。只是一个快速基准测试script 显示，在我的机器上1/(1+|x|) 是最快的，tanh(x) 紧随其后。错误函数erf 也很快。
% gcc -Wall -O2 -lm -o sigmoid-bench{,.c} -std=c99 && ./sigmoid-bench
atan(pi*x/2)*2/pi 24.1 ns
atan(x) 23.0 ns
1/(1+exp(-x)) 20.4 ns
1/sqrt(1+x^2) 13.4 ns
erf(sqrt(pi)*x/2) 6.7 ns
tanh(x) 5.5 ns
x/(1+|x|) 5.5 ns
我预计结果可能会因架构和使用的编译器而异，但 erf(x)（自 C99 起）、tanh(x) 和 x/(1.0+fabs(x)) 可能是性能较快的。
【讨论】：
-
也相信你的意思是说
x/sqrt(1+x^2)而不是1/sqrt(1+x^2)。
您不必在神经网络算法中使用实际的、精确的 sigmoid 函数，但可以将其替换为具有相似属性但计算速度更快的近似版本。
例如，可以使用“fast sigmoid”函数
f(x) = x / (1 + abs(x))
如果 f(x) 的参数不接近于零，则对 exp(x) 使用级数展开的第一项不会有太大帮助，并且如果参数是“大”的。
另一种方法是使用表查找。也就是说，您针对给定数量的数据点预先计算 sigmoid 函数的值，然后根据需要在它们之间进行快速（线性）插值。
【讨论】：
-
不应该是
f(x) = 0.5 * (x / (1 + abs(x)) + 1)来逼近提问者的sigmoid函数f(x) = 1 / (1 + exp(-x))吗？
我认为你不能比内置的 exp() 做得更好，但如果你想要另一种方法，你可以使用级数展开。 WolframAlpha 可以为你计算。
【讨论】：