Rapide sigmoïde algorithme

La fonction sigmoïde est défini comme

J'ai trouvé que l'utilisation de la C de la fonction intégrée dans exp() pour calculer la valeur de f(x) est lente. Est-il plus rapide de l'algorithme pour calculer la valeur de f(x)?

InformationsquelleAutor user416983 | 2012-05-24

algorithm neural-network

29

vous n'avez pas à utiliser le réel, exact fonction sigmoïde dans un réseau de neurones algorithme, mais peut remplacer avec un pseudo version qui a des propriétés similaires, mais il est plus rapide de calcul.

Par exemple, vous pouvez utiliser le "fast sigmoïde" fonction
```
  f(x) = x /(1 + abs(x))
```
À l'aide de premiers termes du développement en série de exp(x) n'aide pas trop si les arguments de f(x) ne sont pas près de zéro, et vous avez le même problème avec un développement en série de la fonction sigmoïde si les arguments sont "grands".

Une alternative est d'utiliser la table de recherche. Qui est, vous précalculer les valeurs de la fonction sigmoïde pour un nombre donné de points de données, puis faire rapide interpolation (linéaire) entre eux si vous le souhaitez.

InformationsquelleAutor Antti Huima
16

Il est préférable de mesurer sur votre matériel tout d'abord. Juste un rapide benchmark script montre, que sur ma machine 1/(1+|x|) est le plus rapide, et tanh(x) est la seconde près. La fonction d'erreur erf est assez rapide aussi.
```
% 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
```
Je m'attends à ce que les résultats peuvent varier en fonction de l'architecture et du compilateur utilisé, mais erf(x) (depuis C99), tanh(x) et x/(1.0+fabs(x)) sont susceptibles d'être rapide artistes interprètes ou exécutants.
- Crois aussi que vous vouliez dire x/sqrt(1+x^2) au lieu de 1/sqrt(1+x^2).
InformationsquelleAutor sastanin
12

Les gens d'ici sont principalement préoccupés par la façon rapide d'une fonction par rapport à l'autre et de créer des micro test pour voir si f1(x) pistes de 0,0001 ms plus vite que f2(x). Le gros problème, c'est que c'est la plupart du temps inutiles, parce que ce qui compte est la vitesse de votre réseau apprend avec votre fonction d'activation en essayant de minimiser vos coûts de fonction.

Que de la théorie actuelle, redresseur de fonction et softplus

par rapport à la fonction sigmoïde ou similaire fonctions d'activation, de permettre
pour plus rapide et efficace de la formation de neurones profonds sur les architectures
de grands ensembles de données complexes.

Alors je vous suggère de jeter des micro-optimisation, et de prendre un coup d'oeil à la fonction qui permet un apprentissage plus rapide (en prenant aussi en regardant divers autres fonction de coût).

InformationsquelleAutor Salvador Dali
7

À faire NN plus souple généralement utilisé quelques alpha taux de changement de l'angle de graphique autour de 0.

La fonction sigmoïde ressemble:
```
f(x) = 1 /( 1+exp(-x*alpha))
```
Près équivalent, (mais plus rapide de la fonction) est:
```
f(x) = 0.5 * (x * alpha /(1 + abs(x*alpha))) + 0.5
```
Vous pouvez vérifier les graphiques ici

Lorsque j'utilise la fonction abs réseau devient plus rapide+ de 100 fois.
- Où est premier tour support censé fermer dans la deuxième équation?
- Fixe, voir en ligne.
InformationsquelleAutor Nosyara
6

Cette réponse n'est probablement pas pertinente pour la plupart des cas, mais je voulais juste jeter là-bas que pour CUDA informatique, j'ai trouvé x/sqrt(1+x^2) pour être le plus rapide de la fonction de loin.

Par exemple, fait avec de simple précision float intrinsèques:
```
__device__ void fooCudaKernel(/* some arguments */) {
    float foo, sigmoid;
    //some code defining foo
    sigmoid = __fmul_rz(rsqrtf(__fmaf_rz(foo,foo,1)),foo);
}
```
- Bon. Mais ne serait si vous le calcul de neurones, Entièrement connectés à la Matrice pas un Vecteur à une seule rangée / de matrices creuses.
InformationsquelleAutor pqn

Aussi vous pouvez utiliser la version grossière de la sigmoïde (il des différences non supérieure à 0,2% de l'original):

    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);
    }

Optimisation de RoughSigmoid fonction avec l'aide de l'ESS:

    #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]);
    }

Optimisation de RoughSigmoid fonction avec l'aide de AVX:

    #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]);
    }

ce que nous en pente ici ? ce sont typiques des entrées sur la fonction

InformationsquelleAutor ErmIg

2

Vous pouvez utiliser un simple mais efficace, en utilisant la méthode à deux formules:
```
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
```
Cela va ressembler à ceci:

Deux graphiques pour une sigmoïde {en Bleu: (0.5/(1+(x^2))), Jaune: (-0.5/(1+(x^2)))+1}

InformationsquelleAutor user9848049
1

À l'aide de Eureqa à la recherche d'approximations sigmoïde j'ai trouvé 1/(1 + 0.3678749025^x) se rapproche de lui. C'est très proche, juste se débarrasser d'une opération, avec la négation de x.

Certaines autres fonctions montrées ici sont intéressants, mais c'est le fonctionnement de la puissance vraiment lent? Je l'ai testé et il a effectivement fait plus rapidement qu'ailleurs, mais ça pourrait simplement être un coup de chance. Si donc, il devrait être tout aussi rapide ou plus rapide que tous les autres.

EDIT:0.5 + 0.5*tanh(0.5*x) et moins précis, 0.5 + 0.5*tanh(n) fonctionne également. Et vous pourrait simplement se débarrasser de l'une des constantes suivantes si vous ne se soucient pas de faire entre l'intervalle [0,1] comme sigmoïde. Mais il suppose que tanh est plus rapide.
- La puissance de ce terme est généralement lente à exécuter oui, d'où ce rapprochement n'évite pas cet aspect de la question d'origine, depuis pow() sera souvent mis en œuvre dans l'UC circuit comme un ajustement à un exp() exécution/évaluation.
InformationsquelleAutor Houshalter
1

La fonction tanh peut être optimisé dans certaines langues, le rendant plus rapide qu'une mesure x/(1+abs(x)), tel est le cas de Julia.

InformationsquelleAutor Qni
-2

Je ne pense pas que vous pouvez faire mieux que dans le haut-exp (), mais si vous voulez une autre approche, vous pouvez utiliser l'extension de la série. WolframAlpha peut calculer pour vous.

InformationsquelleAutor Thomash

Vous devez vous connecter pour publier un commentaire.