[python] 파이썬에서 로지스틱 시그 모이 드 함수를 계산하는 방법은 무엇입니까?

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. C ( http://docs.scipy.org/doc/numpy/reference/ufuncs.html )로 작성된 범용 함수 이므로 호출 오버 헤드 가 있기 때문에 단일 값으로 호출 할 때 expit여전히 파이썬 sigmoid함수 보다 속도가 느립니다 . 이 오버 헤드는 단일 값으로 호출 될 때 컴파일 된 특성으로 인한 계산 속도 향상보다 큽니다 . 그러나 큰 배열에 관해서는 무시할 수 있습니다.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

그러나 실제로 성능이 필요한 경우 일반적인 관행은 RAM에 저장되어있는 시그 모이 드 함수의 미리 계산 된 테이블을 가지고 약간의 속도와 정밀도 및 메모리를 교환하는 것입니다 (예 : http://radimrehurek.com/2013/09). / word2vec-in-python-part-two-optimizing / )

또한 expit버전 0.14.0부터 구현이 수치 적으로 안정적입니다. https://github.com/scipy/scipy/issues/3385

답변

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

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

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

sigmoid = lambda x: .5 * (math.tanh(.5 * x) + 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)

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