Pythonでロジスティックシグモイド関数を計算する方法は？

これはロジスティックシグモイド関数です。

私はxを知っています。PythonでF（x）を計算するにはどうすればよいですか？

x = 0.458としましょう。

F（x）=？

これはそれを行うはずです：

import math

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

そして今あなたは呼び出すことによってそれをテストすることができます：

>>> sigmoid(0.458)
0.61253961344091512

更新：上記は主に、指定された式をPythonコードに1対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。Cで記述された汎用関数（http://docs.scipy.org/doc/numpy/reference/ufuncs.html）であり、単一の値で呼び出された場合expitでも、Python 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（最初のものは配列をサポートしていませんが、計算する値が1つしかない場合ははるかに高速です））

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

内部的には、上記と同じ条件を実装し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より正確になる可能性があります。）

別の方法

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

tanh関数を変換する別の方法：

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

シグモイド関数の形状を変更するための無料パラメーターに多くの人が興味を持っているのではないかと思います。2つ目は、ミラーシグモイド関数を使用する多くのアプリケーションです。3番目に、出力値が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)

numpyパッケージを使用して、シグモイド関数がベクトルを解析できるようにします。

Deeplearningに準拠して、次のコードを使用します。

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

@unwindからの良い回答。ただし、極端な負の数は処理できません（OverflowErrorがスローされます）。

私の改善：

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

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

ロジスティックシグモイド関数の数値的に安定したバージョン。

    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)

ワンライナー...

In[1]: import numpy as np

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

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

pandas DataFrame/Seriesまたはを使用する場合のベクトル化された方法numpy array：

上位の答えは単一点計算用に最適化された方法ですが、これらの方法をパンダシリーズまたはnumpy配列に適用する場合は、 apply、がです。これは非常に非効率的です。

コードを高速化するために、ベクトル化と乱暴なブロードキャストを利用できます。

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

次のように計算できます。

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

import numpy as np

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

result = sigmoid(0.467)
print(result)

上記のコードは、Pythonのロジスティックシグモイド関数です。私が知っているならx = 0.467、シグモイド関数、F(x) = 0.385。上記のコードで知っているxの任意の値を代入してみると、別の値が得られますF(x)。