Softsign Ableitung Rechner

📈 Ableitung der Softsign-Funktion

Schritt-für-Schritt Herleitung:

\[\text{Gegeben: } \text{softsign}(x) = \frac{x}{1 + |x|}\] \[\text{Fallunterscheidung für } |x|:\] \[\text{Fall 1: } x \geq 0 \Rightarrow \text{softsign}(x) = \frac{x}{1 + x}\] \[\frac{d}{dx}\left(\frac{x}{1 + x}\right) = \frac{(1+x) \cdot 1 - x \cdot 1}{(1+x)^2} = \frac{1}{(1+x)^2}\] \[\text{Fall 2: } x < 0 \Rightarrow \text{softsign}(x) = \frac{x}{1 - x}\] \[\frac{d}{dx}\left(\frac{x}{1 - x}\right) = \frac{(1-x) \cdot 1 - x \cdot (-1)}{(1-x)^2} = \frac{1}{(1-x)^2}\]

🔄 Vereinheitlichung

Kompakte Form der Ableitung:

\[\text{Für } x \geq 0: \text{softsign}'(x) = \frac{1}{(1+x)^2} = \frac{1}{(1+|x|)^2}\] \[\text{Für } x < 0: \text{softsign}'(x) = \frac{1}{(1-x)^2} = \frac{1}{(1+|x|)^2}\] \[\text{Vereinheitlicht: } \text{softsign}'(x) = \frac{1}{(1+|x|)^2}\] \[\text{Verifikation: Kontinuierlich bei } x = 0\]

📊 Charakteristische Werte

Wichtige Punkte der Softsign-Ableitung:

\[\text{Maximum bei } x = 0: \quad \text{softsign}'(0) = \frac{1}{(1+0)^2} = 1\] \[\text{Symmetrie: } \text{softsign}'(-x) = \text{softsign}'(x)\] \[\text{Asymptotik: } \lim_{x \to \pm\infty} \text{softsign}'(x) = 0\] \[\text{Halbwertspunkte: } \text{softsign}'(\pm 1) = \frac{1}{4} = 0{,}25\]

📝 Beispiel 1: Backpropagation-Schritt

Aufgabe: Gradientenberechnung in neuronaler Schicht
Gegeben: Aktivierung a = softsign(1.5) ≈ 0.6, Fehler δ = 0.2
Berechnung:

\[\text{Softsign-Wert: } \text{softsign}(1{,}5) = \frac{1{,}5}{1 + 1{,}5} = \frac{1{,}5}{2{,}5} = 0{,}6\] \[\text{Ableitung: } \text{softsign}'(1{,}5) = \frac{1}{(1 + 1{,}5)^2} = \frac{1}{(2{,}5)^2} = \frac{1}{6{,}25} = 0{,}16\] \[\text{Gradient: } \frac{\partial E}{\partial z} = \delta \cdot \text{softsign}'(1{,}5) = 0{,}2 \cdot 0{,}16 = 0{,}032\]

Backpropagation: Sanfterer Gradient im Vergleich zu Tanh

📝 Beispiel 2: Vergleich mit Tanh-Ableitung

Aufgabe: Vergleich der Ableitungen bei verschiedenen Eingaben
Szenario: Gradientenverhalten bei extremen Werten
Berechnung:

\[\text{Bei } x = 3:\] \[\text{Softsign': } \text{softsign}'(3) = \frac{1}{(1+3)^2} = \frac{1}{16} = 0{,}0625\] \[\text{Tanh': } \tanh'(3) = 1 - \tanh^2(3) \approx 1 - (0{,}995)^2 \approx 0{,}01\] \[\text{Verhältnis: } \frac{\text{softsign}'(3)}{\tanh'(3)} \approx \frac{0{,}0625}{0{,}01} = 6{,}25\]

Vorteil: Softsign-Ableitung fällt langsamer ab → weniger Vanishing Gradients

📝 Beispiel 3: Optimale Gewichtsinitialisierung

Aufgabe: Xavier-Initialisierung für Softsign
Ziel: Gradienten in optimaler Größenordnung halten
Berechnung:

\[\text{Erwartete Ableitung bei } x = 0: E[\text{softsign}'(0)] = 1\] \[\text{Varianz der Ableitung: } \text{Var}(\text{softsign}'(x)) \text{ hängt von Eingabeverteilung ab}\] \[\text{Xavier für Softsign: } \sigma_W^2 = \frac{1}{n_{in}} \text{ (angepasst für Maximum 1)}\] \[\text{Resultat: Stärkere Gradienten als bei Tanh/Sigmoid}\]

Praxis: Weniger aggressive Initialisierung nötig als bei sättigenden Funktionen

📊 Ableitungsvergleich-Tabelle

🔄 Gradientenfluß durch Schichten

Rückwärtspropagation mit Softsign-Ableitung:

\[\text{Forward Pass: } z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}, \quad a^{(l)} = \text{softsign}(z^{(l)})\] \[\text{Backward Pass: } \delta^{(l)} = \frac{\partial E}{\partial z^{(l)}}\] \[\text{Kettenregel: } \delta^{(l-1)} = (W^{(l)})^T \delta^{(l)} \odot \text{softsign}'(z^{(l-1)})\] \[\text{Gewichts-Update: } \frac{\partial E}{\partial W^{(l)}} = \delta^{(l)} (a^{(l-1)})^T\]

📈 Vorteil gegenüber Tanh

Warum Softsign-Ableitung vorteilhaft sein kann:

\[\text{Langsamerer Abfall: } \text{softsign}'(x) = \frac{1}{(1+|x|)^2} \text{ vs. } \tanh'(x) = 1-\tanh^2(x)\] \[\text{Bei } |x| = 2: \text{softsign}'(2) = \frac{1}{9} \approx 0{,}111 \text{ vs. } \tanh'(2) \approx 0{,}071\] \[\text{Bei } |x| = 3: \text{softsign}'(3) = \frac{1}{16} = 0{,}0625 \text{ vs. } \tanh'(3) \approx 0{,}01\] \[\text{Resultat: Weniger Vanishing Gradients in tiefen Netzen}\]

💻 Code-Implementierungen

Effiziente Berechnung der Softsign-Ableitung:

Python (NumPy):
def softsign_derivative(x):
  return 1 / ((1 + np.abs(x)) ** 2)

# Wenn softsign bereits berechnet:
def softsign_derivative_from_output(softsign_out):
  # softsign(x) = x/(1+|x|) => |x| = |softsign_out|/(1-|softsign_out|)
  abs_out = np.abs(softsign_out)
  return (1 - abs_out) ** 2

# Backpropagation implementieren:
def backward_pass(delta, x):
  return delta * softsign_derivative(x)

TensorFlow:
# Automatische Differentiation
with tf.GradientTape() as tape:
  y = tf.nn.softsign(x)
dy_dx = tape.gradient(y, x)

⚡ Optimierte Backpropagation

Praktische Implementation für neuronale Netze:

Vollständige Layer-Implementation:
class SoftsignLayer:
  def forward(self, x):
    self.input = x
    self.output = x / (1 + np.abs(x))
    return self.output

  def backward(self, grad_output):
    # Verwendet gespeicherte Eingabe
    softsign_grad = 1 / ((1 + np.abs(self.input)) ** 2)
    return grad_output * softsign_grad

# Verwendung in Training-Loop:
grad_input = layer.backward(grad_from_above)

🎯 Praktische Tipps

Optimierung der Softsign-Ableitung in der Praxis:

\[\text{✓ Numerisch stabil für alle Eingabewerte}\] \[\text{✓ Keine speziellen Grenzfälle zu behandeln}\] \[\text{✓ Einfache Berechnung ohne Exponentialfunktionen}\] \[\text{✓ Vektorisierung effizient möglich}\] \[\text{✓ Gradientenclipping meist nicht nötig}\]