另一种方式

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

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

它也可以在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

如预期的后勤。CDF比出口慢得多。当使用单个值调用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))
   ....: 

(你会注意到数学上的微小变化。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-optimizing/)

另外，请注意，从0.14.0版本开始，出口实现在数值上是稳定的:https://github.com/scipy/scipy/issues/3385

另一种方法是变换tanh函数

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

另一种方式

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

logistic s型函数的数值稳定版本。

    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)