Sigmoid

Sigmoid im Überblick

Sigmoid quetscht jeden Wert in den Bereich 0 bis 1 – perfekt für Wahrscheinlichkeiten.

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

Input:  -∞ ──────── 0 ──────── +∞
Output:  0 ──────── 0.5 ────── 1

        1 │         ___________
          │       /
          │      /
      0.5 │─────●
          │    /
          │___/
        0 └─────────────────────
            -5    0    5

Technisch betrachtet

Implementation

import numpy as np

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

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)  # Maximum bei x=0: 0.25

Vanishing Gradient

# Problem: Gradient wird sehr klein
x = 10
grad = sigmoid_derivative(x)  # ≈ 0.00005

# Bei tiefen Netzen: Gradient → 0
# Lösung: ReLU, GELU, oder Residual Connections

Mathematische Eigenschaften

Drei Eigenschaften machen Sigmoid analytisch besonders angenehm:

Symmetrie:   σ(-x) = 1 - σ(x)
Ableitung:   σ'(x) = σ(x) × (1 - σ(x))
Maximum:     σ'(0) = 0.25

Die Ableitung lässt sich also direkt aus dem Funktionswert berechnen – man braucht keine erneute Auswertung der Exponentialfunktion. Genau diese Eigenschaft machte Sigmoid in den Anfangsjahren der Backpropagation populär. Gleichzeitig zeigt das Maximum von 0.25 das Kernproblem: Selbst im besten Fall schrumpft der Gradient bei jedem Sigmoid-Layer mindestens auf ein Viertel. Über viele Schichten multipliziert sich das zu praktisch null – das Vanishing-Gradient-Problem.

Verbindung zur logistischen Regression

Sigmoid ist die Umkehrfunktion der Logit-Funktion. Die logistische Regression modelliert die Log-Odds als lineare Funktion der Features und schickt das Ergebnis durch Sigmoid:

Logit:  log(p / (1 - p)) = w·x + b
Invers: p = σ(w·x + b)

Der Output lässt sich dadurch direkt als Wahrscheinlichkeit interpretieren – vorausgesetzt, das Modell ist gut kalibriert. Dieselbe Konstruktion steckt im Output-Layer jedes binären Klassifikators mit Binary-Cross-Entropy-Loss.

Sigmoid vs. Tanh vs. Softmax

Tanh ist im Kern eine skalierte und verschobene Sigmoid-Funktion: tanh(x) = 2σ(2x) - 1. Weil Tanh um null zentriert ist, konvergiert Training damit in Hidden Layers oft besser – für moderne tiefe Netze haben aber ReLU-Varianten beide weitgehend abgelöst.

Numerische Stabilität in der Praxis

Die naive Implementierung kann bei stark negativen Eingaben überlaufen, weil e^(-x) dann extrem groß wird. Frameworks nutzen deshalb eine fallweise stabile Formulierung:

def sigmoid_stable(x):
    # Für x >= 0: 1 / (1 + e^(-x)), für x < 0: e^x / (1 + e^x)
    return np.where(x >= 0,
                    1 / (1 + np.exp(-np.abs(x))),
                    np.exp(-np.abs(x)) / (1 + np.exp(-np.abs(x))))

Aus demselben Grund kombinieren PyTorch und TensorFlow Sigmoid und Loss in einer Funktion (BCEWithLogitsLoss bzw. from_logits=True): Die Berechnung auf Logit-Ebene ist numerisch stabiler, als erst Sigmoid und dann den Logarithmus im Loss zu berechnen. In eigenen Trainingsloops sollte man daher rohe Logits an den Loss übergeben statt bereits durch Sigmoid transformierte Werte.