Sigmoid Funktion Rechner

📈 Verschiedene Darstellungen

Äquivalente mathematische Formulierungen:

\[\sigma(t) = \frac{1}{1 + e^{-t}} \quad \text{(Standard-Form)}\] \[\sigma(t) = \frac{e^t}{1 + e^t} \quad \text{(Alternative Form)}\] \[\sigma(t) = \frac{1}{2} \left(1 + \tanh\left(\frac{t}{2}\right)\right) \quad \text{(Tanh-Form)}\] \[\sigma(t) = \frac{1}{2} + \frac{1}{4}\text{sech}^2\left(\frac{t}{2}\right) \quad \text{(Ableitung von Tanh)}\]

🔄 Wichtige Eigenschaften

Fundamentale mathematische Eigenschaften:

\[\text{Symmetrie: } \sigma(-t) = 1 - \sigma(t)\] \[\text{Nullpunkt: } \sigma(0) = 0{,}5\] \[\text{Grenzwerte: } \lim_{t \to -\infty} \sigma(t) = 0, \quad \lim_{t \to +\infty} \sigma(t) = 1\] \[\text{Umkehrfunktion: } \sigma^{-1}(p) = \ln\left(\frac{p}{1-p}\right) \quad \text{(Logit)}\]

📊 Ableitung und Analysis

Wichtige Ableitungseigenschaften:

\[\frac{d\sigma}{dt} = \sigma(t) \cdot (1 - \sigma(t)) \quad \text{(Elegante Form)}\] \[\frac{d\sigma}{dt} = \frac{e^{-t}}{(1 + e^{-t})^2} \quad \text{(Direkte Form)}\] \[\text{Maximum der Ableitung bei } t = 0: \quad \frac{d\sigma}{dt}\Big|_{t=0} = \frac{1}{4}\] \[\text{Wendepunkt bei } t = 0\]

📝 Beispiel 1: Klassische Werte

Aufgabe: Sigmoid-Werte für wichtige Punkte
Berechnung:

\[\sigma(-2) = \frac{1}{1 + e^{2}} = \frac{1}{1 + 7{,}389} \approx 0{,}119 \quad (11{,}9\%)\] \[\sigma(0) = \frac{1}{1 + e^{0}} = \frac{1}{1 + 1} = 0{,}5 \quad (50\%)\] \[\sigma(2) = \frac{1}{1 + e^{-2}} = \frac{1}{1 + 0{,}135} \approx 0{,}881 \quad (88{,}1\%)\]

Symmetrie: σ(-2) + σ(2) = 0.119 + 0.881 = 1 ✓

📝 Beispiel 2: Logistische Regression

Aufgabe: Binäre Klassifikation mit Sigmoid
Szenario: Spam-Erkennung mit linearem Modell
Berechnung:

\[\text{Lineares Modell: } z = w_0 + w_1 x_1 + w_2 x_2\] \[\text{Beispiel: } z = -2 + 3 \cdot 0{,}8 + 1{,}5 \cdot 0{,}6 = -2 + 2{,}4 + 0{,}9 = 1{,}3\] \[P(\text{Spam}) = \sigma(1{,}3) = \frac{1}{1 + e^{-1{,}3}} \approx 0{,}786\] \[\text{Klassifikation: } P > 0{,}5 \Rightarrow \text{Spam} (78{,}6\%) \text{Wahrscheinlichkeit}\]

Interpretation: Hohe Wahrscheinlichkeit für Spam-Klassifikation

📝 Beispiel 3: Neuronales Netzwerk

Aufgabe: Aktivierung in versteckter Schicht
Gegeben: Eingaben [0.5, 0.8], Gewichte [0.3, 0.7], Bias -0.2
Berechnung:

\[\text{Net-Input: } z = \sum w_i x_i + b = 0{,}3 \cdot 0{,}5 + 0{,}7 \cdot 0{,}8 - 0{,}2\] \[z = 0{,}15 + 0{,}56 - 0{,}2 = 0{,}51\] \[\text{Aktivierung: } a = \sigma(0{,}51) = \frac{1}{1 + e^{-0{,}51}} \approx 0{,}625\] \[\text{Ableitung: } \sigma'(0{,}51) = 0{,}625 \cdot (1 - 0{,}625) = 0{,}234\]

Backpropagation: Die Ableitung wird für Gradientenberechnung benötigt

📊 Vergleichstabelle

⚠️ Vanishing Gradient Problem

Hauptproblem der Sigmoid-Funktion in tiefen Netzen:

\[\text{Problem: } \frac{d\sigma}{dt} = \sigma(t)(1-\sigma(t)) \leq \frac{1}{4}\] \[\text{Bei } |t| > 3: \quad \frac{d\sigma}{dt} < 0{,}05 \quad \text{(sehr kleine Gradienten)}\] \[\text{Ketten-Multiplikation: } \prod_{i=1}^{n} \sigma'_i < \left(\frac{1}{4}\right)^n \quad \text{(exponentieller Zerfall)}\] \[\text{Lösung: ReLU, Residual Connections, Batch Normalization}\]

🎯 Moderne Alternativen

Warum andere Aktivierungsfunktionen bevorzugt werden:

\[\text{ReLU: } f(x) = \max(0, x) \quad \text{(keine Sättigung, einfach)}\] \[\text{Swish: } f(x) = x \cdot \sigma(x) \quad \text{(smooth, selbst-gated)}\] \[\text{GELU: } f(x) = x \cdot \Phi(x) \quad \text{(probabilistische Interpretation)}\] \[\text{Verwendung heute: Output-Layer für binäre Klassifikation}\]

💻 Code-Implementierungen

Numerisch stabile Implementierungen:

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

# Numerisch stabil für große |x|:
def stable_sigmoid(x):
  return np.where(x >= 0,
    1 / (1 + np.exp(-x)),
    np.exp(x) / (1 + np.exp(x)))

TensorFlow/Keras:
tf.nn.sigmoid(x)
# oder als Layer:
tf.keras.activations.sigmoid

PyTorch:
torch.sigmoid(x)
# oder
torch.nn.Sigmoid()

📈 Ableitung implementieren

Effiziente Berechnung der Sigmoid-Ableitung:

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

# Oder wenn sigmoid bereits berechnet:
def sigmoid_derivative_from_output(sigmoid_output):
  return sigmoid_output * (1 - sigmoid_output)

# Für Backpropagation verwenden:
gradient = error * sigmoid_derivative_from_output(activation)