Проблемы функции активации Sigmoid, применение и интерпретация

Проблемы функции активации Sigmoid, применение и интерпретация

Sigmoid — классическая функция активации, которая преобразует любое число в диапазон (0, 1). Хотя она исторически важна, у неё есть критические проблемы, которые нужно знать.

Формула и свойства

σ(x) = 1 / (1 + e^(-x))

Свойства:
- Диапазон: (0, 1)
- Производная: σ'(x) = σ(x) * (1 - σ(x))
- Максимум производной: 0.25 (при x = 0)
- Монотонно возрастает

Визуализация

import numpy as np
import matplotlib.pyplot as plt

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

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

x = np.linspace(-10, 10, 1000)
y = sigmoid(x)
dy = sigmoid_derivative(x)

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Сама функция
axes[0].plot(x, y, 'b-', linewidth=2, label='σ(x)')
axes[0].axhline(y=0.5, color='r', linestyle='--', alpha=0.5, label='y=0.5')
axes[0].axvline(x=0, color='g', linestyle='--', alpha=0.5, label='x=0')
axes[0].grid(True, alpha=0.3)
axes[0].set_ylabel('σ(x)')
axes[0].set_xlabel('x')
axes[0].set_title('Функция Sigmoid')
axes[0].legend()
axes[0].set_ylim(-0.1, 1.1)

# Производная
axes[1].plot(x, dy, 'r-', linewidth=2, label="σ'(x)")
axes[1].axhline(y=0.25, color='g', linestyle='--', alpha=0.5, label='max=0.25')
axes[1].grid(True, alpha=0.3)
axes[1].set_ylabel("σ'(x)")
axes[1].set_xlabel('x')
axes[1].set_title('Производная Sigmoid')
axes[1].legend()

plt.tight_layout()
plt.show()

ОСНОВНЫЕ ПРОБЛЕМЫ

1. Vanishing Gradient Problem (исчезающий градиент)

Суть: При |x| > 5, производная σ'(x) ≈ 0, что приводит к исчезновению градиента при backpropagation.

x_values = np.array([-10, -5, 0, 5, 10])
derivatives = sigmoid_derivative(x_values)

print("Проблема исчезающего градиента:")
for x_val, deriv in zip(x_values, derivatives):
    print(f"  x = {x_val:3d}: σ'(x) = {deriv:.6f}")

print("\nВидно: при x = ±10, производная практически 0")
print("Это означает, что градиент почти не проходит через слой")

Последствия:

• Глубокие сети обучаются очень медленно
• Ранние слои практически не обновляются
• Требуются очень маленькие learning rates

Решение: ReLU и другие функции активации, которые имеют производную 1 для положительных значений.

2. Not Zero-Centered Output

Суть: Sigmoid выдаёт значения в (0, 1), а не в (-1, 1). Это усложняет оптимизацию.

print("Sigmoid: выход в диапазоне (0, 1)")
print(f"  Минимум: {sigmoid(-100):.6f}")
print(f"  Максимум: {sigmoid(100):.6f}")
print(f"  При x=0: {sigmoid(0):.6f}")

print("\nПроблема: если входы в сеть всегда положительные,")
print("то при обновлении весов градиент всегда имеет одинаковый знак.")
print("Это замедляет конвергенцию (zigzag path вместо прямого).")

# Демонстрация
class SimpleNetwork:
    def __init__(self):
        self.w = 0.5
    
    def forward(self, x):
        return sigmoid(self.w * x)
    
    def gradient_update(self, x, dw_direction):
        # Если x всегда положительный, dw всегда одного знака
        return x * dw_direction  # Произведение

net = SimpleNetwork()
x_positive = np.array([2.0, 3.0, 1.5, 2.5])  # Всегда > 0

print(f"\nПри положительных входах, градиент всегда положительный:")
for x in x_positive:
    grad = net.gradient_update(x, dw_direction=1.0)
    print(f"  x={x:.1f}: градиент = {grad:.1f} (всегда > 0)")
print("→ Неэффективный путь оптимизации!")

3. Computationally Expensive (exponential)

import time

# Сравнение вычислений
x = np.random.randn(10000000)

# Sigmoid (требует exp)
start = time.time()
y_sigmoid = 1 / (1 + np.exp(-x))
time_sigmoid = time.time() - start

# ReLU (просто max)
start = time.time()
y_relu = np.maximum(0, x)
time_relu = time.time() - start

print(f"Sigmoid: {time_sigmoid*1000:.2f} ms")
print(f"ReLU: {time_relu*1000:.2f} ms")
print(f"Sigmoid медленнее в {time_sigmoid/time_relu:.1f} раз")

ПРИМЕНЕНИЕ

1. Бинарная классификация (Final layer)

import torch
import torch.nn as nn

# В выходном слое бинарной классификации
class BinaryClassifier(nn.Module):
    def __init__(self, input_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, 1)
        self.sigmoid = nn.Sigmoid()  # Для вероятности
    
    def forward(self, x):
        x = torch.relu(x)  # ReLU в скрытых слоях
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.fc2(x)
        x = self.sigmoid(x)  # Sigmoid только на выходе!
        return x

model = BinaryClassifier(input_size=20)
output = model(torch.randn(32, 20))
print(f"Output shape: {output.shape}")
print(f"Output range: ({output.min():.4f}, {output.max():.4f})")
print(f"Интерпретация: вероятность класса 1")

2. Логистическая регрессия

from sklearn.linear_model import LogisticRegression

# LogisticRegression внутри использует sigmoid
model = LogisticRegression()
model.fit(X_train, y_train)

probabilities = model.predict_proba(X_test)[:, 1]
print(f"Вероятности (через sigmoid): {probabilities[:5]}")

# Ручная реализация
logits = X_test @ model.coef_[0] + model.intercept_
predicted_probs = sigmoid(logits)
print(f"То же, что и sigmoid(logits): {predicted_probs[:5]}")

3. Gated механизмы (LSTM, GRU)

# В LSTM ячейках используют sigmoid для гейтов
class LSTMCell:
    def forward(self, x, h_prev, c_prev):
        # Input gate: какую часть нового входа принять
        i_t = sigmoid(W_i @ [x, h_prev] + b_i)  # ∈ [0, 1]
        
        # Forget gate: какую часть памяти забыть
        f_t = sigmoid(W_f @ [x, h_prev] + b_f)  # ∈ [0, 1]
        
        # Output gate: какую часть состояния вывести
        o_t = sigmoid(W_o @ [x, h_prev] + b_o)  # ∈ [0, 1]
        
        # Candidate: новая информация
        c_tilde = tanh(W_c @ [x, h_prev] + b_c)  # ∈ [-1, 1]
        
        # Обновление памяти и скрытого состояния
        c_t = f_t ⊙ c_prev + i_t ⊙ c_tilde
        h_t = o_t ⊙ tanh(c_t)
        
        return h_t, c_t

print("Sigmoid здесь идеален: выбирает из [0,1], как переключатель")

ИНТЕРПРЕТАЦИЯ

# Вероятностная интерпретация
logit = 2.5  # логарифм odds
probability = sigmoid(logit)
odds = np.exp(logit)

print(f"Logit (log-odds): {logit:.2f}")
print(f"Probability: {probability:.4f}")
print(f"Odds: {odds:.2f}:1")
print(f"\nИнтерпретация: вероятность события 0.9241, odds = 12.18:1")
print(f"т.е. событие в 12.18 раз более вероятно, чем не-событие")

# Обратное преобразование (logit функция)
import numpy as np
def logit(p):
    return np.log(p / (1 - p))

p = 0.9
log_odds = logit(p)
print(f"\nОбратно: при p=0.9, logit = {log_odds:.2f}")
print(f"sigmoid({log_odds:.2f}) = {sigmoid(log_odds):.4f}")

РЕКОМЕНДАЦИИ

Используй Sigmoid:

• ✓ Выходной слой бинарной классификации
• ✓ Гейты в RNN/LSTM (нужна вероятность)
• ✓ Когда нужна интерпретируемость как вероятность

НЕ используй Sigmoid:

• ✗ В скрытых слоях глубоких сетей (vanishing gradient)
• ✗ Когда нужна скорость вычислений
• ✗ Когда хочешь zero-centered activation

Альтернативы:

from torch.nn import ReLU, Tanh, GELU, Sigmoid, ELU, LeakyReLU

activations = {
    'ReLU': ReLU(),          # Современный стандарт, простой
    'Tanh': Tanh(),          # Zero-centered, но тоже vanishing gradient
    'GELU': GELU(),          # Хороший выбор для трансформеров
    'Sigmoid': Sigmoid(),    # Только для выходного слоя
    'LeakyReLU': LeakyReLU(), # Лучше ReLU (избегает dead neurons)
}

print("Рекомендация по современным архитектурам:")
print("Скрытые слои: ReLU, LeakyReLU, GELU")
print("Выходной слой бинарной классификации: Sigmoid")
print("Выходной слой мультиклассовой классификации: Softmax")

Вывод: Sigmoid — это инструмент, а не универсальное решение. Используй его только где действительно нужна вероятность на выходе!