如何在Python中计算逻辑sigmoid函数？

Question

这是一个逻辑sigmoid函数:

我知道x.我现在如何在Python中计算F(x)？

比方说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

但是当你真的需要性能时,通常的做法是在RAM中保存一个预先计算的sigmoid函数表,并以一定的速度交换一些精度和内存(例如:http://radimrehurek.com/2013/09/word2vec-in-python-part-two-optimized /)

另请注意,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.

一般来说,多项logistic sigmoid是:

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

I feel many might be interested in free parameters to alter the shape of the sigmoid function. Second for many applications you want to use a mirrored sigmoid function. Third you might want to do a simple normalization for example the output values are between 0 and 1.

Try:

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

And to draw and compare:

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

Finally:

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

Answer 6

通过转换tanh函数的另一种方式：

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

Answer 7

使用numpy包可让您的Sigmoid函数解析向量。

根据深度学习，我使用以下代码：

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