我正在寻找在SSE元素上运算的指数函数的近似值。即 - __m128 exp( __m128 x )。
我的实现很快但准确度很低：
static inline __m128 FastExpSse(__m128 x)
{
__m128 a = _mm_set1_ps(12102203.2f); // (1 << 23) / ln(2)
__m128i b = _mm_set1_epi32(127 * (1 << 23) - 486411);
__m128 m87 = _mm_set1_ps(-87);
// fast exponential function, x should be in [-87, 87]
__m128 mask = _mm_cmpge_ps(x, m87);
__m128i tmp = _mm_add_epi32(_mm_cvtps_epi32(_mm_mul_ps(a, x)), b);
return _mm_and_ps(_mm_castsi128_ps(tmp), mask);
}
是否有人能够以更快的速度（或更快）获得更准确的实施？
如果我用C风格写的话，我会很高兴。
谢谢。
答案 0 :(得分：9)
下面的C代码是我在previous answer中用于类似问题的算法的SSE内在函数的翻译。
基本思想是将标准指数函数的计算转换为2的幂的计算：expf (x) = exp2f (x / logf (2.0f)) = exp2f (x * 1.44269504)。我们将t = x * 1.44269504分为整数i和分数f，以便t = i + f和0 <= f <= 1。我们现在可以用多项式近似计算2 f ，然后通过将i加到单精度浮点数的指数字段中，将结果缩放2 i 点结果。
SSE实现存在的一个问题是我们想要计算i = floorf (t)，但没有快速计算floor()函数的方法。但是，我们观察到正数，floor(x) == trunc(x)和负数floor(x) == trunc(x) - 1，除非x是负整数。但是，由于核心近似可以处理f 1.0f的值，因此使用负参数的近似值是无害的。 SSE提供了将单精度浮点操作数转换为具有截断的整数的指令，因此该解决方案是有效的。
Peter Cordes指出SSE4.1支持快速发言函数_mm_floor_ps()，因此使用SSE4.1的变体也如下所示。当启用SSE 4.1代码生成时，并非所有工具链都会自动预定义宏__SSE4_1__，但gcc会这样做。
编译器资源管理器（Godbolt）显示gcc 7.2将下面的代码编译为普通SSE的sixteen instructions和SSE 4.1的twelve instructions。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <emmintrin.h>
#ifdef __SSE4_1__
#include <smmintrin.h>
#endif
/* max. rel. error = 1.72863156e-3 on [-87.33654, 88.72283] */
__m128 fast_exp_sse (__m128 x)
{
__m128 t, f, e, p, r;
__m128i i, j;
__m128 l2e = _mm_set1_ps (1.442695041f); /* log2(e) */
__m128 c0 = _mm_set1_ps (0.3371894346f);
__m128 c1 = _mm_set1_ps (0.657636276f);
__m128 c2 = _mm_set1_ps (1.00172476f);
/* exp(x) = 2^i * 2^f; i = floor (log2(e) * x), 0 <= f <= 1 */
t = _mm_mul_ps (x, l2e); /* t = log2(e) * x */
#ifdef __SSE4_1__
e = _mm_floor_ps (t); /* floor(t) */
i = _mm_cvtps_epi32 (e); /* (int)floor(t) */
#else /* __SSE4_1__*/
i = _mm_cvttps_epi32 (t); /* i = (int)t */
j = _mm_srli_epi32 (_mm_castps_si128 (x), 31); /* signbit(t) */
i = _mm_sub_epi32 (i, j); /* (int)t - signbit(t) */
e = _mm_cvtepi32_ps (i); /* floor(t) ~= (int)t - signbit(t) */
#endif /* __SSE4_1__*/
f = _mm_sub_ps (t, e); /* f = t - floor(t) */
p = c0; /* c0 */
p = _mm_mul_ps (p, f); /* c0 * f */
p = _mm_add_ps (p, c1); /* c0 * f + c1 */
p = _mm_mul_ps (p, f); /* (c0 * f + c1) * f */
p = _mm_add_ps (p, c2); /* p = (c0 * f + c1) * f + c2 ~= 2^f */
j = _mm_slli_epi32 (i, 23); /* i << 23 */
r = _mm_castsi128_ps (_mm_add_epi32 (j, _mm_castps_si128 (p))); /* r = p * 2^i*/
return r;
}
int main (void)
{
union {
float f[4];
unsigned int i[4];
} arg, res;
double relerr, maxrelerr = 0.0;
int i, j;
__m128 x, y;
float start[2] = {-0.0f, 0.0f};
float finish[2] = {-87.33654f, 88.72283f};
for (i = 0; i < 2; i++) {
arg.f[0] = start[i];
arg.i[1] = arg.i[0] + 1;
arg.i[2] = arg.i[0] + 2;
arg.i[3] = arg.i[0] + 3;
do {
memcpy (&x, &arg, sizeof(x));
y = fast_exp_sse (x);
memcpy (&res, &y, sizeof(y));
for (j = 0; j < 4; j++) {
double ref = exp ((double)arg.f[j]);
relerr = fabs ((res.f[j] - ref) / ref);
if (relerr > maxrelerr) {
printf ("arg=% 15.8e res=%15.8e ref=%15.8e err=%15.8e\n",
arg.f[j], res.f[j], ref, relerr);
maxrelerr = relerr;
}
}
arg.i[0] += 4;
arg.i[1] += 4;
arg.i[2] += 4;
arg.i[3] += 4;
} while (fabsf (arg.f[3]) < fabsf (finish[i]));
}
printf ("maximum relative errror = %15.8e\n", maxrelerr);
return EXIT_SUCCESS;
}
fast_sse_exp()的另一种设计使用众所周知的添加＆＃34; magic＆＃34;的技术，以圆到最近模式提取调整后的参数x / log(2)的整数部分。转换常数1.5 * 2 23 强制在正确的位位置舍入，然后再次减去相同的数字。这要求在加法期间有效的SSE舍入模式是“舍入到最近或甚至＆＃34;”，这是默认值。 wim在评论中指出，当使用积极优化时，某些编译器可能会优化转换常量cvt的加法和减法，从而干扰此代码序列的功能，因此建议使用检查生成的机器代码。计算2 f 的近似区间现在以零为中心，因为-0.5 <= f <= 0.5，需要不同的核近似。
/* max. rel. error <= 1.72860465e-3 on [-87.33654, 88.72283] */
__m128 fast_exp_sse (__m128 x)
{
__m128 t, f, p, r;
__m128i i, j;
const __m128 l2e = _mm_set1_ps (1.442695041f); /* log2(e) */
const __m128 cvt = _mm_set1_ps (12582912.0f); /* 1.5 * (1 << 23) */
const __m128 c0 = _mm_set1_ps (0.238428936f);
const __m128 c1 = _mm_set1_ps (0.703448006f);
const __m128 c2 = _mm_set1_ps (1.000443142f);
/* exp(x) = 2^i * 2^f; i = rint (log2(e) * x), -0.5 <= f <= 0.5 */
t = _mm_mul_ps (x, l2e); /* t = log2(e) * x */
r = _mm_sub_ps (_mm_add_ps (t, cvt), cvt); /* r = rint (t) */
f = _mm_sub_ps (t, r); /* f = t - rint (t) */
i = _mm_cvtps_epi32 (t); /* i = (int)t */
p = c0; /* c0 */
p = _mm_mul_ps (p, f); /* c0 * f */
p = _mm_add_ps (p, c1); /* c0 * f + c1 */
p = _mm_mul_ps (p, f); /* (c0 * f + c1) * f */
p = _mm_add_ps (p, c2); /* p = (c0 * f + c1) * f + c2 ~= exp2(f) */
j = _mm_slli_epi32 (i, 23); /* i << 23 */
r = _mm_castsi128_ps (_mm_add_epi32 (j, _mm_castps_si128 (p))); /* r = p * 2^i*/
return r;
}
问题中代码的算法似乎来自Nicol N. Schraudolph的工作，它巧妙地利用了IEEE-754二进制浮点格式的半对数性质：
<磷>氮。 N. Schraudolph。 ＆＃34;指数函数的快速，紧凑近似。＆＃34; Neural Computation ，11（4），1999年5月，pp.853-862。删除参数钳位代码后，它只减少到三个SSE指令。 ＆＃34;魔法＆＃34;校正常数486411对于最小化整个输入域上的最大相对误差不是最佳的。基于简单的二进制搜索，值298765似乎更优越，将FastExpSse()的最大相对误差降低到3.56e-2，而fast_exp_sse()的最大相对误差为1.73e-3。
/* max. rel. error = 3.55959567e-2 on [-87.33654, 88.72283] */
__m128 FastExpSse (__m128 x)
{
__m128 a = _mm_set1_ps (12102203.0f); /* (1 << 23) / log(2) */
__m128i b = _mm_set1_epi32 (127 * (1 << 23) - 298765);
__m128i t = _mm_add_epi32 (_mm_cvtps_epi32 (_mm_mul_ps (a, x)), b);
return _mm_castsi128_ps (t);
}
Schraudolph的算法基本上使用[0,1]中1.0 + f的线性逼近2 f 〜= f，其精度可以通过添加二次项。 Schraudolph方法的聪明部分是计算2 i * 2 f 而没有明确地将整数部分i = floor(x * 1.44269504)与分数分开。我认为无法将该技巧扩展到二次近似，但是当然可以将Schraudolph的floor()计算与上面使用的二次近似相结合：
/* max. rel. error <= 1.72886892e-3 on [-87.33654, 88.72283] */
__m128 fast_exp_sse (__m128 x)
{
__m128 f, p, r;
__m128i t, j;
const __m128 a = _mm_set1_ps (12102203.0f); /* (1 << 23) / log(2) */
const __m128i m = _mm_set1_epi32 (0xff800000); /* mask for integer bits */
const __m128 ttm23 = _mm_set1_ps (1.1920929e-7f); /* exp2(-23) */
const __m128 c0 = _mm_set1_ps (0.3371894346f);
const __m128 c1 = _mm_set1_ps (0.657636276f);
const __m128 c2 = _mm_set1_ps (1.00172476f);
t = _mm_cvtps_epi32 (_mm_mul_ps (a, x));
j = _mm_and_si128 (t, m); /* j = (int)(floor (x/log(2))) << 23 */
t = _mm_sub_epi32 (t, j);
f = _mm_mul_ps (ttm23, _mm_cvtepi32_ps (t)); /* f = (x/log(2)) - floor (x/log(2)) */
p = c0; /* c0 */
p = _mm_mul_ps (p, f); /* c0 * f */
p = _mm_add_ps (p, c1); /* c0 * f + c1 */
p = _mm_mul_ps (p, f); /* (c0 * f + c1) * f */
p = _mm_add_ps (p, c2); /* p = (c0 * f + c1) * f + c2 ~= 2^f */
r = _mm_castsi128_ps (_mm_add_epi32 (j, _mm_castps_si128 (p))); /* r = p * 2^i*/
return r;
}
答案 1 :(得分：5)
通过使用FastExpSse（x / 2）/ FastExpSse（-x / 2），可以通过整数减法和浮点除法来获得算法精度的良好提高（在上面的答案中实现FastExpSse）而不是FastExpSse（x）。这里的技巧是将移位参数（上面的298765）设置为零，以便分子和分母中的分段线性近似排列为您提供实质性的错误消除。将其转换为单个函数：
__m128 BetterFastExpSse (__m128 x)
{
const __m128 a = _mm_set1_ps ((1 << 22) / float(M_LN2)); // to get exp(x/2)
const __m128i b = _mm_set1_epi32 (127 * (1 << 23)); // NB: zero shift!
__m128i r = _mm_cvtps_epi32 (_mm_mul_ps (a, x));
__m128i s = _mm_add_epi32 (b, r);
__m128i t = _mm_sub_epi32 (b, r);
return _mm_div_ps (_mm_castsi128_ps (s), _mm_castsi128_ps (t));
}
（我不是硬件人 - 这个部门的性能杀手有多糟糕？）
如果你需要exp（x）来获得y = tanh（x）（例如对于神经网络），请使用零偏移的FastExpSse，如下所示：
a = FastExpSse(x);
b = FastExpSse(-x);
y = (a - b)/(a + b);
获得相同类型的错误取消权益。使用具有零移位的FastExpSse（x / 2）/（FastExpSse（x / 2）+ FastExpSse（-x / 2）），逻辑函数的工作方式类似。 （这只是为了说明原理 - 你显然不想在这里多次评估FastExpSse，而是将其按照上面的BetterFastExpSse行推送到单个函数中。）
我确实从中开发了一系列高阶近似，更准确但也更慢。未发表但很高兴合作，如果有人想给他们一个旋转。
最后，为了一些乐趣：使用倒档来获得FastLogSse。使用FastExpSse进行链接可以为您提供操作员和错误消除功能，并且可以提供超快速的功能......
答案 2 :(得分：3)
从那时回到我的笔记，我确实探索了提高准确性的方法而不使用除法。我使用了相同的reinterpret-as-float技巧，但对尾数应用了多项式校正，这基本上是用16位定点算法计算的（当时快速执行它的唯一方法）。
立方体。四分之一版本给你4分。 5位有效数字的准确性。由于低精度算术的噪声随后开始淹没多项式近似的误差，因此没有必要增加超出该顺序的顺序。以下是纯C版本：
#include <stdint.h>
float fastExp3(register float x) // cubic spline approximation
{
union { float f; int32_t i; } reinterpreter;
reinterpreter.i = (int32_t)(12102203.0f*x) + 127*(1 << 23);
int32_t m = (reinterpreter.i >> 7) & 0xFFFF; // copy mantissa
// empirical values for small maximum relative error (8.34e-5):
reinterpreter.i +=
((((((((1277*m) >> 14) + 14825)*m) >> 14) - 79749)*m) >> 11) - 626;
return reinterpreter.f;
}
float fastExp4(register float x) // quartic spline approximation
{
union { float f; int32_t i; } reinterpreter;
reinterpreter.i = (int32_t)(12102203.0f*x) + 127*(1 << 23);
int32_t m = (reinterpreter.i >> 7) & 0xFFFF; // copy mantissa
// empirical values for small maximum relative error (1.21e-5):
reinterpreter.i += (((((((((((3537*m) >> 16)
+ 13668)*m) >> 18) + 15817)*m) >> 14) - 80470)*m) >> 11);
return reinterpreter.f;
}
四分之一服从（fastExp4（0f）== 1f），这对于定点迭代算法很重要。
SSE中这些整数乘法移位序列的效率如何？在浮点运算同样快的架构上，可以使用它来减少算术噪声。这基本上会产生@ njuffa上面答案的立方和四次扩展。
答案 3 :(得分：1)
有一篇有关创建这些方程的快速版本（tanh，cosh，artanh，sinh等）的论文：
http://ijeais.org/wp-content/uploads/2018/07/IJAER180702.pdf “创建英特尔Svml Simd内部函数的编译器优化的嵌入式实现”
第9页上的tanh方程6与@NicSchraudolph答案非常相似
答案 4 :(得分：1)
对于 softmax 的使用，我将流程设想为：
auto a = _mm_mul_ps(x, _mm_set1_ps(12102203.2f));
auto b = _mm_castsi128_ps(_mm_cvtps_epi32(a)); // so far as in other variants
// copy 9 MSB from 0x3f800000 over 'b' so that 1 <= c < 2
// - also 1 <= poly_eval(...) < 2
auto c = replace_exponent(b, _mm_set1_ps(1.0f));
auto d = poly_eval(c, kA, kB, kC); // 2nd degree polynomial
auto e = replace_exponent(d, b); // restore exponent : 2^i * 2^f
可以使用适当的掩码（AVX-512 具有 vpternlogd，而我实际上使用的是 Arm Neon vbsl）以按位选择方式完成指数复制。
所有输入值 x 必须是负数，并且限制在 -17-f(N) <= x <= -f(N) 之间，这样当按 (1<<23)/log( 2），N个结果浮点值的最大和不会达到无穷大，倒数不会变得异常。对于 N=3，f(N) = 4。较大的 f(N) 会牺牲输入精度。
polyeval 系数例如由 polyfit([1 1.5 2],[1 sqrt(2) 2]) 生成，kA=0.343146，kB=-0.029437，kC=0.68292，严格产生小于 2 的值并防止不连续。通过在 x=[1+max_err 1.5-eps 2], y=[1 2^(.5-eps) 2-max_err] 处评估多项式，可以减少最大平均误差。
对于严格的 SSE/AVX，1.0f 的指数替换可以通过 (x & 0x007fffff) | 0x3f800000) 完成。通过确保 poly_eval(x) 求值为一个范围，可以找到用于后一个指数替换的两条指令序列，该范围可以直接与 b & 0xff800000 进行或运算。