Die Sigmoid-Aktivierungsfunktion - Python-Implementierung

In diesem Tutorial werden wir die Sigmoid-Aktivierungsfunktion kennenlernen. Die Sigmoid-Funktion gibt immer einen Wert zwischen 0 und 1 zurück.

Nach diesem Tutorial werden Sie wissen:

• Was ist eine Aktivierungsfunktion?
• Wie implementiert man die Sigmoidfunktion in Python?
• Wie plottet man die Sigmoidfunktion in Python?
• Wo verwenden wir die Sigmoid-Funktion?
• Welche Probleme verursacht die Sigmoid-Aktivierungsfunktion?
• Bessere Alternativen zur Sigmoid-Aktivierung.

Was ist eine Aktivierungsfunktion?

Eine Aktivierungsfunktion ist eine mathematische Funktion, die die Ausgabe eines neuronalen Netzwerks steuert. Aktivierungsfunktionen helfen dabei zu bestimmen, ob ein Neuron aktiviert wird oder nicht.

Einige der beliebten Aktivierungsfunktionen sind:

• Binärer Schritt
• Linear
• Sigmoid
• Tanh
• ReLU
• Leaky ReLU
• Softmax

Die Aktivierung ist verantwortlich dafür, Nicht-Linearität in die Ausgabe eines neuronalen Netzmodells einzufügen. Ohne eine Aktivierungsfunktion ist ein neuronales Netzwerk einfach eine lineare Regression.

Die mathematische Gleichung zur Berechnung des Outputs eines neuronalen Netzwerks lautet:

In diesem Tutorial werden wir uns auf die sigmoidale Aktivierungsfunktion konzentrieren. Diese Funktion stammt aus der sigmoiden Funktion in der Mathematik.

Lass uns damit beginnen, die Formel für die Funktion zu besprechen.

Die Formel für die Sigmoid-Aktivierungsfunktion

Mathematisch kann man die Sigmoid-Aktivierungsfunktion darstellen als:

Sie können sehen, dass der Nenner immer größer als 1 sein wird, daher wird die Ausgabe immer zwischen 0 und 1 liegen.

Implementierung der Sigmoid-Aktivierungsfunktion in Python

In diesem Abschnitt werden wir lernen, wie man die Sigmoid-Aktivierungsfunktion in Python implementiert.

Wir können die Funktion in Python wie folgt definieren:

import numpy as np 
def sig(x):
 return 1/(1 + np.exp(-x))

Lass uns versuchen, die Funktion mit einigen Eingaben auszuführen.

import numpy as np 
def sig(x):
 return 1/(1 + np.exp(-x))


x = 1.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = -10.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = 0.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = 15.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = -2.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

Ausgabe :

Applying Sigmoid Activation on (1.0) gives 0.7
Applying Sigmoid Activation on (-10.0) gives 0.0
Applying Sigmoid Activation on (0.0) gives 0.5
Applying Sigmoid Activation on (15.0) gives 1.0
Applying Sigmoid Activation on (-2.0) gives 0.1

Sigmoid-Aktivierung mit Python plotten

Um die Sigmoid-Aktivierung darzustellen, verwenden wir die Numpy-Bibliothek:

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 50)   
p = sig(x)
plt.xlabel("x") 
plt.ylabel("Sigmoid(x)")  
plt.plot(x, p) 
plt.show()

Ausgabe :

Wir können sehen, dass die Ausgabe zwischen 0 und 1 liegt.

Die Sigmoidfunktion wird häufig zur Vorhersage von Wahrscheinlichkeiten verwendet, da die Wahrscheinlichkeit immer zwischen 0 und 1 liegt.

Einer der Nachteile der Sigmoidfunktion ist, dass die Y-Werte in den Endbereichen sehr gering auf die Veränderung der X-Werte reagieren.

Dies führt zu einem Problem, das als verschwindendes Gradientproblem bekannt ist.

Der verschwindende Gradient verlangsamt den Lernprozess und ist daher unerwünscht.

Lass uns einige Alternativen besprechen, die dieses Problem überwinden.

ReLu Aktivierungsfunktion

Eine bessere Alternative, die das Problem des verschwindenden Gradienten löst, ist die ReLu-Aktivierungsfunktion.

Die ReLu-Aktivierungsfunktion gibt 0 zurück, wenn der Input negativ ist, andernfalls gibt sie den Input unverändert zurück.

Mathematisch wird es dargestellt als:

Sie können es in Python wie folgt implementieren:

def relu(x):
    return max(0.0, x)

Lass uns sehen, wie es bei einigen Eingaben funktioniert.

def relu(x):
    return max(0.0, x)
 
x = 1.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = -10.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = 0.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = 15.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = -20.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))

Ausgabe :

Applying Relu on (1.0) gives 1.0
Applying Relu on (-10.0) gives 0.0
Applying Relu on (0.0) gives 0.0
Applying Relu on (15.0) gives 15.0
Applying Relu on (-20.0) gives 0.0

Das Problem mit ReLu ist, dass der Gradient für negative Eingaben null beträgt.

Dies führt erneut zum Problem des verschwindenden Gradienten (Nullgradient) für negative Eingaben.

Um dieses Problem zu lösen, haben wir eine andere Alternative, die als Leaky ReLu-Aktivierungsfunktion bekannt ist.

Leaky ReLu Aktivierungsfunktion

Die leaky ReLu löst das Problem der Nullgradienten für negative Werte, indem sie negativen Eingaben einen extrem kleinen linearen Anteil von x verleiht.

Mathematisch können wir es definieren als:

f(x)= 0.01x, x<0
    = x,   x>=0

Sie können es in Python implementieren mit:

def leaky_relu(x):
  if x>0 :
    return x
  else :
    return 0.01*x
  
x = 1.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = -10.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = 0.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = 15.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = -20.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

Ausgabe :

Applying Leaky Relu on (1.0) gives 1.0
Applying Leaky Relu on (-10.0) gives -0.1
Applying Leaky Relu on (0.0) gives 0.0
Applying Leaky Relu on (15.0) gives 15.0
Applying Leaky Relu on (-20.0) gives -0.2

Schlussfolgerung

Dieses Tutorial handelte von der Sigmoid-Aktivierungsfunktion. Wir haben gelernt, wie man die Funktion in Python implementiert und zeichnet.