Как рассчитать логистическую сигмоидную функцию в Python?

Question

Это логистическая сигмоидальная функция:

Я знаю х.Как я могу вычислить F (x) в Python сейчас?

Скажем, x = 0,458.

F (x) =?

Answer 1

Он также доступен в scipy: http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.logistic.html

In [1]: from scipy.stats import logistic

In [2]: logistic.cdf(0.458)
Out[2]: 0.61253961344091512

, который является только дорогостоящей оболочкой (поскольку позволяет масштабировать и переводить логистическую функцию) другой функции scipy:

In [3]: from scipy.special import expit

In [4]: expit(0.458)
Out[4]: 0.61253961344091512

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

Некоторые тесты:

In [5]: def sigmoid(x):
  ....:     return 1 / (1 + math.exp(-x))
  ....: 

In [6]: %timeit -r 1 sigmoid(0.458)
1000000 loops, best of 1: 371 ns per loop


In [7]: %timeit -r 1 logistic.cdf(0.458)
10000 loops, best of 1: 72.2 µs per loop

In [8]: %timeit -r 1 expit(0.458)
100000 loops, best of 1: 2.98 µs per loop

Как и ожидалось logistic.cdf(намного) медленнее, чем expit.expit все еще медленнее, чем функция Python sigmoid, когда вызывается с одним значением, потому что это универсальная функция, написанная на C (http://docs.scipy.org/doc/numpy/reference/ufuncs.html) и, следовательно, имеет накладные расходы на вызов.Эти издержки больше, чем ускорение вычислений expit, заданное его скомпилированной природой при вызове с одним значением.Но это становится незначительным, когда дело доходит до больших массивов:

In [9]: import numpy as np

In [10]: x = np.random.random(1000000)

In [11]: def sigmoid_array(x):                                        
   ....:    return 1 / (1 + np.exp(-x))
   ....: 

(Вы заметите небольшое изменение с math.exp до np.exp (первый не поддерживает массивы, но намного быстрее, еслиу вас есть только одно значение для вычисления))

In [12]: %timeit -r 1 -n 100 sigmoid_array(x)
100 loops, best of 1: 34.3 ms per loop

In [13]: %timeit -r 1 -n 100 expit(x)
100 loops, best of 1: 31 ms per loop

Но когда вам действительно нужна производительность, обычная практика - иметь предварительно вычисленную таблицу сигмоидальной функции, которая хранится в оперативной памяти, и обмениваться некоторой точностью и памятью.для некоторой скорости (например: http://radimrehurek.com/2013/09/word2vec-in-python-part-two-optimizing/)

Также обратите внимание, что реализация expit численно стабильна с версии 0.14.0: https://github.com/scipy/scipy/issues/3385

Answer 2

Это должно сделать это:

import math

def sigmoid(x):
  return 1 / (1 + math.exp(-x))

И теперь вы можете проверить это, позвонив по телефону:

>>> sigmoid(0.458)
0.61253961344091512

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

Answer 3

Вот как бы вы реализовали логистическую сигмоиду численно стабильным способом (как описано здесь ):

def sigmoid(x):
    "Numerically-stable sigmoid function."
    if x >= 0:
        z = exp(-x)
        return 1 / (1 + z)
    else:
        z = exp(x)
        return z / (1 + z)

Или, возможно, это более точно:

import numpy as np

def sigmoid(x):  
    return math.exp(-np.logaddexp(0, -x))

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

Как правило, полиномиальная логистическая сигмоида имеет вид:

def nat_to_exp(q):
    max_q = max(0.0, np.max(q))
    rebased_q = q - max_q
    return np.exp(rebased_q - np.logaddexp(-max_q, np.logaddexp.reduce(rebased_q)))

(Однако,logaddexp.reduce может быть более точным.)

Answer 4

другой способ

>>> def sigmoid(x):
...     return 1 /(1+(math.e**-x))
...
>>> sigmoid(0.458)

Answer 5

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

В соответствии с Deeplearning я использую следующий код:

import numpy as np
def sigmoid(x):
    s = 1/(1+np.exp(-x))
    return s

Answer 6

Я чувствую, что многие могут быть заинтересованы в свободных параметрах для изменения формы сигмовидной функции. Во-вторых, для многих приложений вы хотите использовать зеркальную сигмовидную функцию. В-третьих, вы можете выполнить простую нормализацию, например, выходные значения находятся в диапазоне от 0 до 1.

Попытка:

def normalized_sigmoid_fkt(a, b, x):
   '''
   Returns array of a horizontal mirrored normalized sigmoid function
   output between 0 and 1
   Function parameters a = center; b = width
   '''
   s= 1/(1+np.exp(b*(x-a)))
   return 1*(s-min(s))/(max(s)-min(s)) # normalize function to 0-1

И нарисовать и сравнить:

def draw_function_on_2x2_grid(x): 
    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
    plt.subplots_adjust(wspace=.5)
    plt.subplots_adjust(hspace=.5)

    ax1.plot(x, normalized_sigmoid_fkt( .5, 18, x))
    ax1.set_title('1')

    ax2.plot(x, normalized_sigmoid_fkt(0.518, 10.549, x))
    ax2.set_title('2')

    ax3.plot(x, normalized_sigmoid_fkt( .7, 11, x))
    ax3.set_title('3')

    ax4.plot(x, normalized_sigmoid_fkt( .2, 14, x))
    ax4.set_title('4')
    plt.suptitle('Different normalized (sigmoid) function',size=10 )

    return fig

Наконец:

x = np.linspace(0,1,100)
Travel_function = draw_function_on_2x2_grid(x)

Answer 7

Другой способ преобразования функции tanh:

sigmoid = lambda x: .5 * (math.tanh(.5 * x) + 1)

Answer 8

Хороший ответ от @unwind. Однако он не может обработать крайнее отрицательное число (выбрасывая OverflowError).

Мое улучшение:

def sigmoid(x):
    try:
        res = 1 / (1 + math.exp(-x))
    except OverflowError:
        res = 0.0
    return res

Answer 9

Численно стабильная версия функции логистической сигмоиды.

    def sigmoid(x):
        pos_mask = (x >= 0)
        neg_mask = (x < 0)
        z = np.zeros_like(x,dtype=float)
        z[pos_mask] = np.exp(-x[pos_mask])
        z[neg_mask] = np.exp(x[neg_mask])
        top = np.ones_like(x,dtype=float)
        top[neg_mask] = z[neg_mask]
        return top / (1 + z)

Answer 10

Tensorflow включает также функцию sigmoid: https://www.tensorflow.org/versions/r1.2/api_docs/python/tf/sigmoid

import tensorflow as tf

sess = tf.InteractiveSession()
x = 0.458
y = tf.sigmoid(x)

u = y.eval()
print(u)
# 0.6125396