ReLu-Funktion in Python

Relu oder Rektifizierte lineare Aktivierungsfunktion ist die am häufigsten gewählte Aktivierungsfunktion im Bereich des tiefen Lernens. Relu liefert Ergebnisse auf dem neuesten Stand der Technik und ist gleichzeitig rechnerisch sehr effizient.

Das grundlegende Konzept der Relu-Aktivierungsfunktion ist wie folgt:

Return 0 if the input is negative otherwise return the input as it is.

Wir können es mathematisch wie folgt darstellen:

Der Pseudocode für Relu ist wie folgt:

if input > 0:
	return input
else:
	return 0

In diesem Tutorial werden wir lernen, wie man unsere eigene ReLu-Funktion implementiert, einige ihrer Nachteile kennen lernen und eine bessere Version von ReLu kennenlernen.

Empfohlene Lektüre: Lineare Algebra für Maschinelles Lernen [Teil 1/2]

Lass uns anfangen!

ReLu-Funktion in Python implementieren

Lass uns unsere eigene Implementierung von Relu in Python schreiben. Wir werden die integrierte max-Funktion verwenden, um sie zu implementieren.

Der Code für ReLu ist wie folgt:

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

Um die Funktion zu testen, lassen Sie uns sie mit einigen Eingaben ausführen.

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)))

Vollständiger Code

Der vollständige Code ist unten angegeben:

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

Gradient der ReLu-Funktion

Lass uns sehen, was der Gradient (Ableitung) der ReLu-Funktion wäre. Bei der Differentiation erhalten wir die folgende Funktion:

f'(x) = 1, x>=0
      = 0, x<0

Wir können sehen, dass der Gradient für Werte von x kleiner als null 0 ist. Das bedeutet, dass die Gewichte und Biases einiger Neuronen nicht aktualisiert werden. Dies kann ein Problem im Trainingsprozess darstellen.

Um dieses Problem zu überwinden, haben wir die Leaky ReLu-Funktion. Lassen Sie uns als nächstes darüber lernen.

Undichte ReLu-Funktion

Die Leaky ReLu-Funktion ist eine Verbesserung der regulären ReLu-Funktion. Um das Problem des Nullgradienten bei negativen Werten zu beheben, gibt Leaky ReLu einen äußerst kleinen linearen Anteil von x für negative Eingaben.

Mathematisch können wir Leaky ReLu wie folgt ausdrücken:

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

Mathematisch:

• f(x)=1 (x<0)

Hier ist a eine kleine Konstante wie die 0,01, die wir oben genommen haben.

Grafisch kann es wie folgt dargestellt werden:

Der Gradient von Leaky ReLu

Lass uns den Gradienten für die Leaky ReLu-Funktion berechnen. Der Gradient kann wie folgt aussehen:

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

In diesem Fall ist der Gradient für negative Eingaben ungleich null. Das bedeutet, dass alle Neuronen aktualisiert werden.

Implementierung von Leaky ReLu in Python

Die Implementierung für Leaky ReLu ist wie folgt angegeben:

def relu(x):
  if x>0 :
    return x
  else :
    return 0.01*x

Lass es uns vor Ort mit Eingaben ausprobieren.

 
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)))

Vollständiger Code

Der vollständige Code für Leaky ReLu ist unten angegeben:

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 ReLu-Funktion in Python. Wir haben auch eine verbesserte Version der ReLu-Funktion gesehen. Die Leaky ReLu löst das Problem der Null-Graienten für negative Werte in der ReLu-Funktion.