Математическая оптимизация в C#

Идея: Возможно, вы можете создать (большую) справочную таблицу с предварительно рассчитанными значениями?

Пытаться:

public static float Sigmoid(double value) {
    return 1.0f / (1.0f + (float) Math.Exp(-value));
}

Обновлено: Я сделал быстрый тест. На моей машине приведенный выше код примерно на 43% быстрее, чем ваш метод, и этот математически эквивалентный код немного быстрее (на 46% быстрее оригинала):

public static float Sigmoid(double value) {
    float k = Math.Exp(value);
    return k / (1.0f + k);
}

Обновлено еще раз: Я не уверен, сколько накладных расходов у функций C#, но если вы используете #include <math.h> в исходном коде, вы сможете использовать это, которое использует функцию float-exp. Это могло быть немного быстрее.

public static float Sigmoid(double value) {
    float k = expf((float) value);
    return k / (1.0f + k);
}

Кроме того, если вы выполняете миллионы вызовов, накладные расходы на вызов функций могут быть проблемой. Попробуйте создать встроенную функцию и посмотрите, поможет ли это.

При 100 миллионах звонков я бы начал задаваться вопросом, не искажают ли накладные расходы профилировщика ваши результаты. Замените вычисление бездействующим и посмотрите, сообщается ли, что по-прежнему потребляет 60% времени выполнения ...

Или, что еще лучше, создайте несколько тестовых данных и используйте таймер секундомера для профилирования миллиона или около того звонков.

Выполнив поиск в Google, я нашел альтернативную реализацию сигмоидной функции.

public double Sigmoid(double x)
{
   return 2 / (1 + Math.Exp(-2 * x)) - 1;
}

Это правильно для ваших нужд? Это быстрее?

http://dynamicnotions.blogspot.com/2008/09/sigmoid-function-in-c.html

Если это для функции активации, имеет ли значение, если вычисление e ^ x является полностью точным?

Например, если вы используете приближение (1 + x / 256) ^ 256, в моем тестировании Pentium на Java (я предполагаю, что C# по существу компилируется с теми же инструкциями процессора), это примерно в 7-8 раз быстрее, чем e ^ x (Math.exp ()) и имеет точность до 2 десятичных знаков примерно до x, равного +/- 1,5, и в пределах правильного порядка величины во всем указанном вами диапазоне. (Очевидно, что для увеличения до 256 вы фактически возводите это число в квадрат 8 раз - не используйте для этого Math.Pow!) В Java:

double eapprox = (1d + x / 256d);
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;
eapprox *= eapprox;

Продолжайте удваивать или уменьшать вдвое 256 (и добавлять / удалять умножение) в зависимости от того, насколько точным должно быть приближение. Даже при n = 4 он по-прежнему дает около 1,5 десятичных знаков точности для значений x между -0,5 и 0,5 (и оказывается в 15 раз быстрее, чем Math.exp ()).

P.S. Я забыл упомянуть - вам, очевидно, не следует делить В самом деле на 256: умножать на константу 1/256. Компилятор Java JIT выполняет эту оптимизацию автоматически (по крайней мере, Hotspot делает), и я предполагал, что C# тоже должен это делать.

Первая мысль: как насчет статистики по переменной значений?

• Являются ли значения "value" обычно маленькими -10 <= value <= 10?

Если нет, вы, вероятно, можете получить импульс, протестировав значения за пределами границ.

if (value < -10)  return 0;
if (value > 10)  return 1;

• Часто ли повторяются значения?

Если да, то, вероятно, вы можете получить некоторую выгоду от Мемоизация (возможно, нет, но проверить не помешает ....)

if (sigmoidCache.containsKey(value)) return sigmoidCache.get(value);

Если ни один из них не может быть применен, то, как предлагали некоторые другие, возможно, вам удастся снизить точность вашей сигмовидной кишки ...

(Обновлено с учетом измерений производительности) (Обновлено снова с реальными результатами :)

Я думаю, что решение с помощью таблицы поиска поможет вам очень далеко, когда дело доходит до производительности, с незначительными затратами на память и точность.

Следующий фрагмент - это пример реализации на C (я недостаточно бегло говорю на C#, чтобы писать код). Он работает и работает достаточно хорошо, но я уверен, что в нем есть ошибка :)

#include <math.h>
#include <stdio.h>
#include <time.h>

#define SCALE 320.0f
#define RESOLUTION 2047
#define MIN -RESOLUTION / SCALE
#define MAX RESOLUTION / SCALE

static float sigmoid_lut[RESOLUTION + 1];

void init_sigmoid_lut(void) {
    int i;    
    for (i = 0; i < RESOLUTION + 1; i++) {
        sigmoid_lut[i] =  (1.0 / (1.0 + exp(-i / SCALE)));
    }
}

static float sigmoid1(const float value) {
    return (1.0f / (1.0f + expf(-value)));
}

static float sigmoid2(const float value) {
    if (value <= MIN) return 0.0f;
    if (value >= MAX) return 1.0f;
    if (value >= 0) return sigmoid_lut[(int)(value * SCALE + 0.5f)];
    return 1.0f-sigmoid_lut[(int)(-value * SCALE + 0.5f)];
}

float test_error() {
    float x;
    float emax = 0.0;

    for (x = -10.0f; x < 10.0f; x+=0.00001f) {
        float v0 = sigmoid1(x);
        float v1 = sigmoid2(x);
        float error = fabsf(v1 - v0);
        if (error > emax) { emax = error; }
    } 
    return emax;
}

int sigmoid1_perf() {
    clock_t t0, t1;
    int i;
    float x, y = 0.0f;

    t0 = clock();
    for (i = 0; i < 10; i++) {
        for (x = -5.0f; x <= 5.0f; x+=0.00001f) {
            y = sigmoid1(x);
        }
    }
    t1 = clock();
    printf("", y); /* To avoid sigmoidX() calls being optimized away */
    return (t1 - t0) / (CLOCKS_PER_SEC / 1000);
}

int sigmoid2_perf() {
    clock_t t0, t1;
    int i;
    float x, y = 0.0f;
    t0 = clock();
    for (i = 0; i < 10; i++) {
        for (x = -5.0f; x <= 5.0f; x+=0.00001f) {
            y = sigmoid2(x);
        }
    }
    t1 = clock();
    printf("", y); /* To avoid sigmoidX() calls being optimized away */
    return (t1 - t0) / (CLOCKS_PER_SEC / 1000);
}

int main(void) {
    init_sigmoid_lut();
    printf("Max deviation is %0.6f\n", test_error());
    printf("10^7 iterations using sigmoid1: %d ms\n", sigmoid1_perf());
    printf("10^7 iterations using sigmoid2: %d ms\n", sigmoid2_perf());

    return 0;
}

Предыдущие результаты были связаны с тем, что оптимизатор выполнял свою работу и оптимизировал вычисления. Если заставить его действительно выполнить код, это дает несколько другие и гораздо более интересные результаты (на моем пути медленный MB Air):

$ gcc -O2 test.c -o test && ./test
Max deviation is 0.001664
10^7 iterations using sigmoid1: 571 ms
10^7 iterations using sigmoid2: 113 ms

ДЕЛАТЬ:

Есть вещи, которые нужно улучшить, и способы устранения слабых мест; как это сделать - это упражнение для читателя :)

• Настройте диапазон функции, чтобы избежать скачка там, где таблица начинается и заканчивается.
• Добавьте функцию легкого шума, чтобы скрыть артефакты сглаживания.
• Как сказал Рекс, интерполяция может дать вам немного больше точности, будучи довольно дешевой с точки зрения производительности.

У Сопрано было несколько хороших оптимизаций для вашего звонка:

public static float Sigmoid(double value) 
{
    float k = Math.Exp(value);
    return k / (1.0f + k);
}

Если вы попробуете поисковую таблицу и обнаружите, что она использует слишком много памяти, вы всегда можете посмотреть значение вашего параметра для каждого последующего вызова и использовать некоторую технику кэширования.

Например, попробуйте кэшировать последнее значение и результат. Если следующий вызов имеет то же значение, что и предыдущий, вам не нужно рассчитывать его, поскольку вы бы кэшировали последний результат. Если бы текущий вызов был таким же, как предыдущий, даже 1 раз из 100, вы потенциально могли бы сэкономить 1 миллион вычислений.

Или вы можете обнаружить, что в течение 10 последовательных вызовов параметр value в среднем будет одинаковым 2 раза, поэтому вы можете попробовать кэшировать последние 10 значений / ответов.

1) Вы звоните из одного места? Если это так, вы можете получить небольшую производительность, переместив код из этой функции и просто поместив его туда, где вы обычно вызывали бы сигмовидную функцию. Мне не нравится эта идея с точки зрения удобочитаемости и организации кода, но когда вам нужно добиться максимального прироста производительности, это может помочь, потому что я думаю, что вызовы функций требуют push / pop регистров в стеке, чего можно избежать, если весь код был встроенным.

2) Понятия не имею, может ли это помочь, но попробуйте сделать параметр функции параметром ref. Посмотри, будет ли это быстрее. Я бы предложил сделать его константным (что было бы оптимизацией, если бы это было в С ++), но C# не поддерживает константные параметры.

Вы также можете попробовать поэкспериментировать с альтернативными функциями активации, которые дешевле оценить. Например:

f(x) = (3x - x**3)/2

(что может быть учтено как

f(x) = x*(3 - x*x)/2

на одно умножение меньше). Эта функция имеет нечетную симметрию, а ее производная тривиальна. Использование его для нейронной сети требует нормализации суммы входов путем деления на общее количество входов (ограничение домена до [-1..1], что также является диапазоном).

1. Помните, что любые изменения в этой функции активации происходят за счет различного поведения. Это даже включает переключение на плавание (и, таким образом, снижение точности) или использование заменителей активации. Только экспериментирование с вашим вариантом использования покажет правильный путь.
2. В дополнение к простой оптимизации кода я бы также рекомендовал рассмотреть распараллеливание вычислений (то есть: использовать несколько ядер вашей машины или даже машин в облаках Windows Azure) и улучшить алгоритмы обучения.

Обновлено:Публикация в справочных таблицах для функций активации ИНС

ОБНОВЛЕНИЕ2: Я удалил точку на LUT, так как я перепутал их с полным хешированием. Спасибо Хенрик Густафссон за то, что вернули меня на трассу. Таким образом, память не является проблемой, хотя пространство поиска все еще немного испорчено из-за локальных экстремумов.

Если вы можете взаимодействовать с C++, вы можете рассмотреть возможность сохранения всех значений в массиве и перебирать их, используя SSE следующим образом:

void sigmoid_sse(float *a_Values, float *a_Output, size_t a_Size){
    __m128* l_Output = (__m128*)a_Output;
    __m128* l_Start  = (__m128*)a_Values;
    __m128* l_End    = (__m128*)(a_Values + a_Size);

    const __m128 l_One        = _mm_set_ps1(1.f);
    const __m128 l_Half       = _mm_set_ps1(1.f / 2.f);
    const __m128 l_OneOver6   = _mm_set_ps1(1.f / 6.f);
    const __m128 l_OneOver24  = _mm_set_ps1(1.f / 24.f);
    const __m128 l_OneOver120 = _mm_set_ps1(1.f / 120.f);
    const __m128 l_OneOver720 = _mm_set_ps1(1.f / 720.f);
    const __m128 l_MinOne     = _mm_set_ps1(-1.f);

    for(__m128 *i = l_Start; i < l_End; i++){
        // 1.0 / (1.0 + Math.Pow(Math.E, -value))
        // 1.0 / (1.0 + Math.Exp(-value))

        // value = *i so we need -value
        __m128 value = _mm_mul_ps(l_MinOne, *i);

        // exp expressed as inifite series 1 + x + (x ^ 2 / 2!) + (x ^ 3 / 3!) ...
        __m128 x = value;

        // result in l_Exp
        __m128 l_Exp = l_One; // = 1

        l_Exp = _mm_add_ps(l_Exp, x); // += x

        x = _mm_mul_ps(x, x); // = x ^ 2
        l_Exp = _mm_add_ps(l_Exp, _mm_mul_ps(l_Half, x)); // += (x ^ 2 * (1 / 2))

        x = _mm_mul_ps(value, x); // = x ^ 3
        l_Exp = _mm_add_ps(l_Exp, _mm_mul_ps(l_OneOver6, x)); // += (x ^ 3 * (1 / 6))

        x = _mm_mul_ps(value, x); // = x ^ 4
        l_Exp = _mm_add_ps(l_Exp, _mm_mul_ps(l_OneOver24, x)); // += (x ^ 4 * (1 / 24))

#ifdef MORE_ACCURATE

        x = _mm_mul_ps(value, x); // = x ^ 5
        l_Exp = _mm_add_ps(l_Exp, _mm_mul_ps(l_OneOver120, x)); // += (x ^ 5 * (1 / 120))

        x = _mm_mul_ps(value, x); // = x ^ 6
        l_Exp = _mm_add_ps(l_Exp, _mm_mul_ps(l_OneOver720, x)); // += (x ^ 6 * (1 / 720))

#endif

        // we've calculated exp of -i
        // now we only need to do the '1.0 / (1.0 + ...' part
        *l_Output++ = _mm_rcp_ps(_mm_add_ps(l_One,  l_Exp));
    }
}

Однако помните, что массивы, которые вы будете использовать, должны выделяться с помощью _aligned_malloc (some_size * sizeof (float), 16), потому что SSE требует памяти, выровненной по границе.

Используя SSE, я могу вычислить результат для всех 100 миллионов элементов примерно за полсекунды. Однако выделение такого количества памяти за один раз обойдется вам почти в две трети гигабайта, поэтому я бы предложил обрабатывать за раз больше массивов, но меньшего размера. Возможно, вы даже захотите рассмотреть возможность использования метода двойной буферизации с элементами 100K или более.

Кроме того, если количество элементов начинает значительно расти, вы можете захотеть обработать эти вещи на графическом процессоре (просто создайте 1D текстуру float4 и запустите очень тривиальный фрагментный шейдер).

Вне всяких сомнений, в этой статье объясняется способ аппроксимации экспоненты путем злоупотребления числами с плавающей запятой. (щелкните ссылку в правом верхнем углу для PDF), но я не знаю, будет ли это полезно для вас в .NET.

Еще один момент: для быстрого обучения больших сетей логистическая сигмоида, которую вы используете, довольно ужасна. См. Раздел 4.4 Эффективное обратное распространение, LeCun et al. и используйте что-нибудь с нулевым центром (на самом деле, прочтите всю статью, это очень полезно).

Мягкая вариация на тему Сопрано:

public static float Sigmoid(double value) {
    float v = value;
    float k = Math.Exp(v);
    return k / (1.0f + k);
}

Поскольку вам нужен только результат с одинарной точностью, зачем заставлять функцию Math.Exp вычислять двойную? Любой калькулятор экспоненты, который использует итеративное суммирование (см. расширение e^x), каждый раз требует больше времени для большей точности. А двойной - это вдвое больше, чем одиночный! Таким образом, вы сначала конвертируете в одиночный, тогда делает вашу экспоненту.

Но функция expf должна быть еще быстрее. Я не вижу необходимости в приведении сопрано (float) при передаче в expf, если только C# не выполняет неявное преобразование float-double.

В противном случае просто используйте язык настоящий, например FORTRAN ...

Взгляните на эта почта. у него есть приближение для e ^ x, написанное на Java, это должен быть код C# для него (непроверенный):

public static double Exp(double val) {  
    long tmp = (long) (1512775 * val + 1072632447);  
    return BitConverter.Int64BitsToDouble(tmp << 32);  
}

В моих тестах это больше, чем В 5 раз быстрее, чем Math.exp () (в Java). Приближение основано на документе «Быстрая компактная аппроксимация экспоненциальной функции», который был разработан специально для использования в нейронных сетях. Это в основном то же самое, что таблица поиска из 2048 записей и линейного приближения между записями, но все это с уловками IEEE с плавающей запятой.

Обновлено: Согласно Специальный соус это примерно в 3,25 раза быстрее, чем реализация CLR. Спасибо!

Если вам нужен гигантский прирост скорости, вы, вероятно, могли бы рассмотреть возможность распараллеливания функции с помощью силы (ge). IOW, используйте DirectX, чтобы видеокарта сделала это за вас. Я понятия не имею, как это сделать, но я видел, как люди использовали видеокарты для всех видов вычислений.

Примечание: Это продолжение сообщения это.

Редактировать: Обновите, чтобы вычислить то же, что и это и это, взяв за основу это.

А теперь посмотри, что ты заставил меня сделать! Вы заставили меня установить Mono!

$ gmcs -optimize test.cs && mono test.exe
Max deviation is 0.001663983
10^7 iterations using Sigmoid1() took 1646.613 ms
10^7 iterations using Sigmoid2() took 237.352 ms

С вряд ли стоит затраченных усилий, мир движется вперед :)

Итак, чуть более 10 раз в 6 быстрее. Кто-то с коробкой Windows может исследовать использование памяти и производительность с помощью MS-вещей :)

Использование LUT для функций активации - не такая уж редкость, особенно при аппаратной реализации. Есть много хорошо зарекомендовавших себя вариантов этой концепции, если вы хотите включить эти типы таблиц. Однако, как уже указывалось, сглаживание может оказаться проблемой, но есть и способы обойти это. Дальнейшее чтение:

• NEURObjects от Джорджио Валентини (есть еще статья по этому поводу)
• Нейронные сети с функциями активации цифровых LUT
• Повышение эффективности извлечения функций нейронной сети за счет функций активации с пониженной точностью
• Новый алгоритм обучения нейронных сетей с целочисленными весами и квантованными нелинейными функциями активации
• Влияние квантования на нейронные сети функций высокого порядка

Некоторые проблемы с этим:

• Ошибка увеличивается, когда вы выходите за пределы таблицы (но сходится к 0 в крайних точках); для x примерно + -7,0. Это связано с выбранным масштабным коэффициентом. Большие значения SCALE дают более высокие ошибки в среднем диапазоне, но меньшие по краям.
• Это вообще очень глупый тест, и я не знаю C#, это просто преобразование моего C-кода :)
• Ринат Абдуллин очень верен в том, что сглаживание и потеря точности могут вызвать проблемы, но, поскольку я не видел переменных для этого, я могу только посоветовать вам попробовать это. Фактически, я согласен со всем, что он говорит, кроме вопроса о таблицах поиска.

Простите за кодирование копипаста ...

using System;
using System.Diagnostics;

class LUTTest {
    private const float SCALE = 320.0f;
    private const int RESOLUTION = 2047;
    private const float MIN = -RESOLUTION / SCALE;
    private const float MAX = RESOLUTION / SCALE;

    private static readonly float[] lut = InitLUT();

    private static float[] InitLUT() {
      var lut = new float[RESOLUTION + 1];

      for (int i = 0; i < RESOLUTION + 1; i++) {
        lut[i] = (float)(1.0 / (1.0 + Math.Exp(-i / SCALE)));
      }
      return lut;
    }

    public static float Sigmoid1(double value) {
        return (float) (1.0 / (1.0 + Math.Exp(-value)));
    }

    public static float Sigmoid2(float value) {
      if (value <= MIN) return 0.0f;
      if (value >= MAX) return 1.0f;
      if (value >= 0) return lut[(int)(value * SCALE + 0.5f)];
      return 1.0f - lut[(int)(-value * SCALE + 0.5f)];
    }

    public static float error(float v0, float v1) {
      return Math.Abs(v1 - v0);
    }

    public static float TestError() {
        float emax = 0.0f;
        for (float x = -10.0f; x < 10.0f; x+= 0.00001f) {
          float v0 = Sigmoid1(x);
          float v1 = Sigmoid2(x);
          float e = error(v0, v1);
          if (e > emax) emax = e;
        }
        return emax;
    }

    public static double TestPerformancePlain() {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 10; i++) {
            for (float x = -5.0f; x < 5.0f; x+= 0.00001f) {
                Sigmoid1(x);
            }
        }
        sw.Stop();
        return sw.Elapsed.TotalMilliseconds;
    }    

    public static double TestPerformanceLUT() {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 10; i++) {
            for (float x = -5.0f; x < 5.0f; x+= 0.00001f) {
                Sigmoid2(x);
            }
        }
        sw.Stop();
        return sw.Elapsed.TotalMilliseconds;
    }    

    static void Main() {
        Console.WriteLine("Max deviation is {0}", TestError());
        Console.WriteLine("10^7 iterations using Sigmoid1() took {0} ms", TestPerformancePlain());
        Console.WriteLine("10^7 iterations using Sigmoid2() took {0} ms", TestPerformanceLUT());
    }
}

F# имеет лучшую производительность, чем C# в математических алгоритмах .NET. Таким образом, переписывание нейронной сети на F# может улучшить общую производительность.

Если мы повторно реализуем Фрагмент сравнительного анализа LUT (я использовал слегка измененную версию) в F#, то полученный код:

• выполняет тест sigmoid1 в 588,8 мс вместо 3899,2 мс
• выполняет тест sigmoid2 (LUT) в 156,6 мс вместо 411,4 мс

Более подробную информацию можно найти в Сообщение блога. Вот фрагмент кода JIC на F#:

#light

let Scale = 320.0f;
let Resolution = 2047;

let Min = -single(Resolution)/Scale;
let Max = single(Resolution)/Scale;

let range step a b =
  let count = int((b-a)/step);
  seq { for i in 0 .. count -> single(i)*step + a };

let lut = [| 
  for x in 0 .. Resolution ->
    single(1.0/(1.0 +  exp(-double(x)/double(Scale))))
  |]

let sigmoid1 value = 1.0f/(1.0f + exp(-value));

let sigmoid2 v = 
  if (v <= Min) then 0.0f;
  elif (v>= Max) then 1.0f;
  else
    let f = v * Scale;
    if (v>0.0f) then lut.[int (f + 0.5f)]
    else 1.0f - lut.[int(0.5f - f)];

let getError f = 
  let test = range 0.00001f -10.0f 10.0f;
  let errors = seq { 
    for v in test -> 
      abs(sigmoid1(single(v)) - f(single(v)))
  }
  Seq.max errors;

open System.Diagnostics;

let test f = 
  let sw = Stopwatch.StartNew(); 
  let mutable m = 0.0f;
  let result = 
    for t in 1 .. 10 do
      for x in 1 .. 1000000 do
        m <- f(single(x)/100000.0f-5.0f);
  sw.Elapsed.TotalMilliseconds;

printf "Max deviation is %f\n" (getError sigmoid2)
printf "10^7 iterations using sigmoid1: %f ms\n" (test sigmoid1)
printf "10^7 iterations using sigmoid2: %f ms\n" (test sigmoid2)

let c = System.Console.ReadKey(true);

И вывод (компиляция релиза для F# 1.9.6.2 CTP без отладчика):

Max deviation is 0.001664
10^7 iterations using sigmoid1: 588.843700 ms
10^7 iterations using sigmoid2: 156.626700 ms

Обновлено: обновил бенчмаркинг, чтобы использовать 10 ^ 7 итераций, чтобы результаты были сопоставимы с C

ОБНОВЛЕНИЕ2: вот результаты производительности C реализация с той же машины для сравнения:

Max deviation is 0.001664
10^7 iterations using sigmoid1: 628 ms
10^7 iterations using sigmoid2: 157 ms

Это немного не по теме, но просто из любопытства я сделал ту же реализацию, что и в C, C# и F# в Java. Я просто оставлю это здесь на случай, если кому-то еще будет любопытно.

Результат:

$ javac LUTTest.java && java LUTTest
Max deviation is 0.001664
10^7 iterations using sigmoid1() took 1398 ms
10^7 iterations using sigmoid2() took 177 ms

Я полагаю, что улучшение по сравнению с C# в моем случае связано с тем, что Java лучше оптимизирована, чем Mono для OS X. В аналогичной реализации MS .NET (по сравнению с Java 6, если кто-то хочет опубликовать сравнительные числа), я полагаю, результаты будут разными .

Код:

public class LUTTest {
    private static final float SCALE = 320.0f;
    private static final  int RESOLUTION = 2047;
    private static final  float MIN = -RESOLUTION / SCALE;
    private static final  float MAX = RESOLUTION / SCALE;

    private static final float[] lut = initLUT();

    private static float[] initLUT() {
        float[] lut = new float[RESOLUTION + 1];

        for (int i = 0; i < RESOLUTION + 1; i++) {
            lut[i] = (float)(1.0 / (1.0 + Math.exp(-i / SCALE)));
        }
        return lut;
    }

    public static float sigmoid1(double value) {
        return (float) (1.0 / (1.0 + Math.exp(-value)));
    }

    public static float sigmoid2(float value) {
        if (value <= MIN) return 0.0f;
        if (value >= MAX) return 1.0f;
        if (value >= 0) return lut[(int)(value * SCALE + 0.5f)];
        return 1.0f - lut[(int)(-value * SCALE + 0.5f)];
    }

    public static float error(float v0, float v1) {
        return Math.abs(v1 - v0);
    }

    public static float testError() {
        float emax = 0.0f;
        for (float x = -10.0f; x < 10.0f; x+= 0.00001f) {
            float v0 = sigmoid1(x);
            float v1 = sigmoid2(x);
            float e = error(v0, v1);
            if (e > emax) emax = e;
        }
        return emax;
    }

    public static long sigmoid1Perf() {
        float y = 0.0f;
        long t0 = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            for (float x = -5.0f; x < 5.0f; x+= 0.00001f) {
                y = sigmoid1(x);
            }
        }
        long t1 = System.currentTimeMillis();
        System.out.printf("",y);
        return t1 - t0;
    }    

    public static long sigmoid2Perf() {
        float y = 0.0f;
        long t0 = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            for (float x = -5.0f; x < 5.0f; x+= 0.00001f) {
                y = sigmoid2(x);
            }
        }
        long t1 = System.currentTimeMillis();
        System.out.printf("",y);
        return t1 - t0;
    }    

    public static void main(String[] args) {

        System.out.printf("Max deviation is %f\n", testError());
        System.out.printf("10^7 iterations using sigmoid1() took %d ms\n", sigmoid1Perf());
        System.out.printf("10^7 iterations using sigmoid2() took %d ms\n", sigmoid2Perf());
    }
}

FWIW, вот мои тесты C# для уже опубликованных ответов. (Empty - это функция, которая просто возвращает 0, чтобы измерить накладные расходы на вызов функции)

Empty Function:       79ms   0
Original:             1576ms 0.7202294
Simplified: (soprano) 681ms  0.7202294
Approximate: (Neil)   441ms  0.7198783
Bit Manip: (martinus) 836ms  0.72318
Taylor: (Rex Logan)   261ms  0.7202305
Lookup: (Henrik)      182ms  0.7204863

public static object[] Time(Func<double, float> f) {
    var testvalue = 0.9456;
    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < 1e7; i++)
        f(testvalue);
    return new object[] { sw.ElapsedMilliseconds, f(testvalue) };
}
public static void Main(string[] args) {
    Console.WriteLine("Empty:       {0,10}ms {1}", Time(Empty));
    Console.WriteLine("Original:    {0,10}ms {1}", Time(Original));
    Console.WriteLine("Simplified:  {0,10}ms {1}", Time(Simplified));
    Console.WriteLine("Approximate: {0,10}ms {1}", Time(ExpApproximation));
    Console.WriteLine("Bit Manip:   {0,10}ms {1}", Time(BitBashing));
    Console.WriteLine("Taylor:      {0,10}ms {1}", Time(TaylorExpansion));
    Console.WriteLine("Lookup:      {0,10}ms {1}", Time(LUT));
}

Здесь есть много хороших ответов. Я бы посоветовал запустить его через эта техника, просто чтобы убедиться

• Вы не звоните ему больше, чем нужно. (Иногда функции вызываются чаще, чем необходимо, просто потому, что их так легко вызвать.)
• Вы не вызываете его повторно с одними и теми же аргументами (где вы могли бы использовать мемоизацию)

Кстати, у вас есть функция обратного логита,
или обратная логарифмическая функция отношения шансов log(f/(1-f)).

Я понимаю, что прошел год с тех пор, как этот вопрос возник, но я столкнулся с ним из-за обсуждения производительности F# и C по сравнению с C#. Я поиграл с некоторыми примерами от других респондентов и обнаружил, что делегаты выполняются быстрее, чем вызов обычного метода, но у F# нет очевидного преимущества в производительности перед C#.

• C: 166 мс
• C# (делегат): 275 мс
• C# (метод): 431 мс
• C# (метод, счетчик чисел с плавающей запятой): 2656 мс
• F#: 404 мс

C# со счетчиком с плавающей запятой был прямым портом кода C. Гораздо быстрее использовать int в цикле for.

Есть гораздо более быстрые функции, которые делают очень похожие вещи:

x / (1 + abs(x)) - быстрая замена TAHN

И аналогично:

x / (2 + 2 * abs(x)) + 0.5 - быстрая замена SIGMOID

Сравните графики с реальной сигмоидой

Я видел, что многие здесь пытаются использовать приближение, чтобы сделать сигмоид быстрее. Однако важно знать, что сигмовидная форма также может быть выражена с помощью tanh, а не только exp. Расчет сигмоида таким способом примерно в 5 раз быстрее, чем с экспоненциальным, и, используя этот метод, вы ничего не приближаете, поэтому исходное поведение сигмоида сохраняется как есть.

    public static double Sigmoid(double value)
    {
        return 0.5d + 0.5d * Math.Tanh(value/2);
    }

Конечно, парелизация была бы следующим шагом к повышению производительности, но что касается необработанных вычислений, использование Math.Tanh быстрее, чем Math.Exp.

Помните, что результаты ограничений Сигмовидная находятся в диапазоне от 0 до 1. Значения меньше примерно -10 возвращают значение, очень, очень близкое к 0,0. Значения больше примерно 10 возвращают значение, очень и очень близкое к 1.

В старые времена, когда компьютеры не могли так хорошо справляться с арифметическим переполнением / потерей значимости, установка условий для ограничения вычислений была обычным делом. Если бы меня беспокоила В самом деле его производительность (или, в основном, производительность Math), я бы изменил ваш код на старомодный способ (и не обращал внимания на ограничения), чтобы он не вызывал Math без надобности:

public double Sigmoid(double value)
{
    if (value < -45.0) return 0.0;
    if (value > 45.0) return 1.0;
    return 1.0 / (1.0 + Math.Exp(-value));
}

Я понимаю, что любой, кто читает этот ответ, может быть вовлечен в какую-то разработку NN. Помните, как вышеперечисленное влияет на другие аспекты ваших тренировочных результатов.