Это то, что сработало для меня. Очень простой jQuery и CSS, чтобы сделать отзывчивые карусели независимо от каруселей на одной странице. Высоко настраиваемый, но в основном div с белым пространством nowrap, содержащий кучу встроенных элементов блока и ставит последний в начале, чтобы вернуться назад или первый в конец, чтобы двигаться вперед. Спасибо insertAfter
!
$('.carosel-control-right').click(function() {
$(this).blur();
$(this).parent().find('.carosel-item').first().insertAfter($(this).parent().find('.carosel-item').last());
});
$('.carosel-control-left').click(function() {
$(this).blur();
$(this).parent().find('.carosel-item').last().insertBefore($(this).parent().find('.carosel-item').first());
});
@media (max-width: 300px) {
.carosel-item {
width: 100%;
}
}
@media (min-width: 300px) {
.carosel-item {
width: 50%;
}
}
@media (min-width: 500px) {
.carosel-item {
width: 33.333%;
}
}
@media (min-width: 768px) {
.carosel-item {
width: 25%;
}
}
.carosel {
position: relative;
background-color: #000;
}
.carosel-inner {
white-space: nowrap;
overflow: hidden;
font-size: 0;
}
.carosel-item {
display: inline-block;
}
.carosel-control {
position: absolute;
top: 50%;
padding: 15px;
box-shadow: 0 0 10px 0px rgba(0, 0, 0, 0.5);
transform: translateY(-50%);
border-radius: 50%;
color: rgba(0, 0, 0, 0.5);
font-size: 30px;
display: inline-block;
}
.carosel-control-left {
left: 15px;
}
.carosel-control-right {
right: 15px;
}
.carosel-control:active,
.carosel-control:hover {
text-decoration: none;
color: rgba(0, 0, 0, 0.8);
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="carosel" id="carosel1">
<a class="carosel-control carosel-control-left glyphicon glyphicon-chevron-left" href="#"></a>
<div class="carosel-inner">
<img class="carosel-item" src="http://placehold.it/500/bbbbbb/fff&text=1" />
<img class="carosel-item" src="http://placehold.it/500/CCCCCC&text=2" />
<img class="carosel-item" src="http://placehold.it/500/eeeeee&text=3" />
<img class="carosel-item" src="http://placehold.it/500/f4f4f4&text=4" />
<img class="carosel-item" src="http://placehold.it/500/fcfcfc/333&text=5" />
<img class="carosel-item" src="http://placehold.it/500/f477f4/fff&text=6" />
</div>
<a class="carosel-control carosel-control-right glyphicon glyphicon-chevron-right" href="#"></a>
</div>
<div class="carosel" id="carosel2">
<a class="carosel-control carosel-control-left glyphicon glyphicon-chevron-left" href="#"></a>
<div class="carosel-inner">
<img class="carosel-item" src="http://placehold.it/500/bbbbbb/fff&text=1" />
<img class="carosel-item" src="http://placehold.it/500/CCCCCC&text=2" />
<img class="carosel-item" src="http://placehold.it/500/eeeeee&text=3" />
<img class="carosel-item" src="http://placehold.it/500/f4f4f4&text=4" />
<img class="carosel-item" src="http://placehold.it/500/fcfcfc/333&text=5" />
<img class="carosel-item" src="http://placehold.it/500/f477f4/fff&text=6" />
</div>
<a class="carosel-control carosel-control-right glyphicon glyphicon-chevron-right" href="#"></a>
</div>
Это должно сделать это:
import math
def sigmoid(x):
return 1 / (1 + math.exp(-x))
И теперь вы можете протестировать его, вызвав:
>>> sigmoid(0.458)
0.61253961344091512
Обновление: обратите внимание, что вышеупомянутое в основном предназначалось как прямое -to-one перевод данного выражения в код Python. Это not проверено или известно как цифровая версия. Если вы знаете, что вам нужна очень надежная реализация, я уверен, что есть другие люди, которые действительно задали эту проблему, подумали.
Хороший ответ от @unwind. Однако он не может обрабатывать крайнее отрицательное число (бросая OverflowError).
Мое улучшение:
def sigmoid(x):
try:
res = 1 / (1 + math.exp(-x))
except OverflowError:
res = 0.0
return res
Используйте пакет numpy, чтобы ваша сигмоидальная функция могла анализировать векторы.
В соответствии с Deeplearning я использую следующий код:
import numpy as np
def sigmoid(x):
s = 1/(1+np.exp(-x))
return s
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):
... return 1 /(1+(math.e**-x))
...
>>> sigmoid(0.458)
Другой способ: преобразование функции tanh
:
sigmoid = lambda x: .5 * (math.tanh(.5 * x) + 1)
Вот как вы могли бы реализовать логический сигмоид с численным стабильностью (как описано здесь здесь ):
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)))
Я чувствую, что многие могут интересоваться свободными параметрами, чтобы изменить форму сигмоидной функции. Во-вторых, для многих приложений вы хотите использовать зеркальную сигмовидную функцию. В-третьих, вы можете сделать простую нормализацию, например, выходные значения находятся в диапазоне от 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)
Он также доступен в 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
Но когда вам действительно нужна производительность, обычной практикой является наличие предварительно вычисленной таблицы сигмовидной функции, хранящейся в ОЗУ, и торговля некоторой точностью и память для некоторой скорости (например: 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):
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)