Как рассчитать логистическую сигмоидную функцию в Python?
Это логистическая сигмоидальная функция:
Я знаю х. Как я могу вычислить F(x) в Python сейчас?
Допустим, х = 0,458.
F(x) =?
17 ответов
Это должно сделать это:
import math
def sigmoid(x):
return 1 / (1 + math.exp(-x))
И теперь вы можете проверить это, позвонив:
>>> sigmoid(0.458)
0.61253961344091512
Обновление: обратите внимание, что вышеупомянутое было главным образом предназначено как прямой перевод данного выражения в код 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, expit все еще медленнее чем питон 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
Но когда вам действительно нужна производительность, обычная практика состоит в том, чтобы предварительно рассчитать таблицу сигмоидальной функции, которая хранится в оперативной памяти, и обменять некоторую точность и память на некоторую скорость (например, 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 может быть более точным.)
Еще один способ путем преобразования tanh функция:
sigmoid = lambda x: .5 * (math.tanh(.5 * x) + 1)
Я чувствую, что многие могут быть заинтересованы в свободных параметрах для изменения формы сигмовидной функции. Во-вторых, для многих приложений вы хотите использовать зеркальную сигмовидную функцию. В-третьих, вы можете выполнить простую нормализацию, например, выходные значения находятся в диапазоне от 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
По -другому
>>> 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
Хороший ответ от @unwind. Однако он не может обработать крайнее отрицательное число (выбрасывая OverflowError).
Мое улучшение:
def sigmoid(x):
try:
res = 1 / (1 + math.exp(-x))
except OverflowError:
res = 0.0
return res
Численно стабильная версия функции логистической сигмоиды.
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
Вы можете просто объявить
>>> def sigmoid(x):
... return 1 /(1 + 1 / np.exp(x))
...
>>> sigmoid(0.458)
Векторизованный метод при использовании pandas DataFrame/Series или numpy array:
Лучшие ответы - это оптимизированные методы для вычисления одной точки, но если вы хотите применить эти методы к серии pandas или массиву 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))
Ниже приведена функция Python, которая делает то же самое.
def sigmoid(x) :
return 1.0/(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).
Если у вас есть вектор или массив для вычисления сигмоидальной функции, то вы можете использовать numpy:
import numpy as np
def sigmoid(x):
s = 1/(1+ np.exp(-x))
return s
x= np.array([1,2,3])
sigmoid (x)
вы получите желаемый результат.