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

Умеренное изменение на теме Сопрано:

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

, Так как Вы только после результата одинарной точности, почему делают Математику. Функция Exp вычисляет двойное? Любой калькулятор экспоненты, который использует повторяющееся суммирование (см. расширение e <глоток> x ) займет больше времени у большей точности, каждый раз. И дважды дважды работа сингла! Таким образом, Вы преобразовываете в сингл сначала, тогда делают Ваш экспоненциал.

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

Иначе, просто используйте реальный язык, как ФОРТРАН...

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

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

(который мог быть учтен как

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

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

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

Это немного вне темы, но только из любопытства, я сделал ту же реализацию как та в 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, лучше оптимизируемого, чем Моно для OS X. На подобной реализации.NET MS (по сравнению с 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());
    }
}

Сначала мысль: Как насчет некоторой статистики на переменной значений?

• значения "значения" обычно маленькие-10 < = оцените < = 10?

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

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

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

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

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

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

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

Редактирование: Обновление для вычисления того же самого как это и это , беря некоторое вдохновение от это .

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

$ 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

C едва больше стоит усилия, мир продвигается:)

Так, только по фактору <забастовка> 10 6 быстрее. Кто-то с полем окон добирается для исследования использования памяти и производительности с помощью материала MS:)

Используя LUTs для функций активации не таким образом редкий, особенно, когда реализовано в аппаратных средствах. Существует много хорошо доказанных вариантов понятия там, если Вы готовы включать те типы таблиц. Однако, как были уже указаны, искажение могло бы оказаться проблемой, но существуют пути вокруг этого также. Некоторые дополнительные материалы для чтения:

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

Некоторые глюки с этим:

• ошибка повышается, когда Вы достигаете вне таблицы (но сходится к 0 в экстремальных значениях); для x приблизительно +-7.0. Это происходит из-за выбранного масштабного коэффициента. Большие значения МАСШТАБА дают более высокие ошибки в среднем диапазоне, но меньший в краях.
• Это обычно - очень глупый тест, и я не знаю C#, Это - просто простое преобразование моего C-кода:)
• Rinat Abdullin очень корректен, что искажение и потеря точности могло бы вызвать проблемы, но так как я не видел переменные, за которые я могу только совет Вы для попытки этого. На самом деле я соглашаюсь со всем, что он говорит за исключением выпуска таблиц поиска.

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

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 в [1 115], 588,8 мс вместо 3899,2 мс
• выполняют sigmoid2 (LUT) сравнительный тест в [1 116] 156,6 мс вместо 411,4 мс

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

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

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