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

Question

这是一个逻辑 sigmoid 函数：

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

假设 x = 0.458。

F(x) = ?

Answer 1

这应该这样做：

import math

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

现在你可以通过调用来测试它：

>>> sigmoid(0.458)
0.61253961344091512

更新：请注意，以上内容主要是将给定表达式直接一对一地转换为 Python 代码。它没有经过测试或已知是数字上合理的实现。如果你知道你需要一个非常健壮的实现，我敢肯定还有其他人实际上已经考虑过这个问题。

Answer 2

它也可用于 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函数慢，因为它是用 C ( http://docs.scipy.org/doc/numpy/reference/ufuncs.html ) 编写的通用函数，因此具有调用开销。当使用单个值调用时，此开销大于其编译性质给出的计算加速。但是当涉及到大数组时，它变得可以忽略不计：sigmoidexpit

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.expto的微小变化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-optimizing/ )

另外，请注意，expit自 0.14.0 版以来，实现在数值上是稳定的：https ://github.com/scipy/scipy/issues/3385

Answer 3

以下是您如何以数值稳定的方式实现逻辑 sigmoid（如此处所述）：

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 np.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

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

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

Answer 5

我觉得很多人可能对改变 sigmoid 函数形状的自由参数感兴趣。其次，对于许多要使用镜像 sigmoid 函数的应用程序。第三，您可能想做一个简单的归一化，例如输出值介于 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 6

使用 numpy 包允许您的 sigmoid 函数解析向量。

根据 Deeplearning，我使用以下代码：

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

Answer 7

其他方式

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

Answer 8

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

Answer 9

Logistic sigmoid 函数的数值稳定版本。

    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

@unwind 的好答案。然而，它不能处理极端的负数（抛出 OverflowError）。

我的改进：

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

Answer 11

一个班轮...

In[1]: import numpy as np

In[2]: sigmoid=lambda x: 1 / (1 + np.exp(-x))

In[3]: sigmoid(3)
Out[3]: 0.9525741268224334

Answer 12

使用pandas DataFrame/Seriesor时的向量化方法numpy array：

最佳答案是针对单点计算的优化方法，但是当您想将这些方法应用于 pandas 系列或 numpy 数组时，它需要apply，这基本上是后台的 for 循环，并将遍历每一行并应用该方法。这是相当低效的。

为了加快我们的代码速度，我们可以利用向量化和 numpy 广播：

x = np.arange(-5,5)
np.divide(1, 1+np.exp(-x))

0    0.006693
1    0.017986
2    0.047426
3    0.119203
4    0.268941
5    0.500000
6    0.731059
7    0.880797
8    0.952574
9    0.982014
dtype: float64

或使用pandas Series：

x = pd.Series(np.arange(-5,5))
np.divide(1, 1+np.exp(-x))

Answer 13

您可以将其计算为：

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

或概念性的，更深入且没有任何导入：

def sigmoid(x):
  return 1 / (1 + 2.718281828 ** -x)

或者您可以将 numpy 用于矩阵：

import numpy as np #make sure numpy is already installed
def sigmoid(x):
  return 1 / (1 + np.exp(-x))

Answer 14

import numpy as np

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

result = sigmoid(0.467)
print(result)

上面的代码是python中的逻辑sigmoid函数。如果我知道x = 0.467， sigmoid 函数，F(x) = 0.385。您可以尝试替换上面代码中已知的任何 x 值，您将得到不同的F(x).

Answer 15

下面是执行相同操作的 python 函数。

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

Answer 16

1 / np.exp(x)如果把-放在x之前，您可以简单地声明让您感到困惑。

>>> def sigmoid(x):
...     return 1 /(1 + 1 / np.exp(x))
...
>>> sigmoid(0.458)