[PYTHON] Deep Learning / Aktivierungsfunktionen

1. Zuallererst

Einfach ausgedrückt, die reichhaltige Ausdruckskraft neuronaler Netze beruht auf der Verschachtelung einfacher Aktivierungsfunktionen in tiefe Hierarchien.

Dieses Mal werde ich zusammenfassen, was ich über die Aktivierungsfunktion in neuronalen Netzen gelernt habe.

2. Sigmoidfunktion

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

#Differenzierung der Sigmoidfunktion
def sigmoid_d(x):
    return (1 / (1 + np.exp(-x))) * ( 1- (1 / (1 + np.exp(-x))))

#Grafikanzeige
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, sigmoid(x), label='sigmoid')
plt.plot(x, sigmoid_d(x), label='sigmoid_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Sigmoidfunktion: **

sigmoid(x) = \frac{1}{1+e^{-x}}

** Differenzierung der Sigmoidfunktion: **

sigmoid'(x) = \frac{1}{1+e^{-x}} * ( 1 - \frac{1}{1+e^{-x}})

Die Sigmoid-Funktion ist seit langem in Lehrbüchern für neuronale Netze enthalten und hat eine schöne Form, bei der sich die Form fast nicht ändert, selbst wenn sie differenziert ist. Heutzutage wird sie jedoch selten als Aktivierungsfunktion verwendet.

Der Grund ist, dass, wie Sie in der Grafik sehen können, y mit zunehmendem Wert von x bei 1 bleibt und stecken bleibt. Dies liegt daran, dass das neuronale Netzwerk y differenziert, um die Steigung zu erhalten, und den Gewichtsparameter optimiert. Wenn die Differenzierung also fast 0 wird, hat es das Problem, dass es sich nicht der optimalen Lösung nähern kann (Verschwinden des Gradienten).

** Ableitung der Differenzierung der Sigmoidfunktion **

sigmoid'(x) = ((1 + e^{-x})^{-1})'\\

Durch Differenzieren der zusammengesetzten Funktion wird u= 1+e^{-x}Wenn Sie setzen\frac{dy}{dx}=\frac{dy}{du}\frac{du}{dx}Damit\\

= -(1 + e^{-x})^{-2} * (1+e^{-x})'\\

= -\frac{1}{(1+e^{-x})^2} * -e^{-x}\\

= \frac{1}{1+e^{-x}} * \frac{e^{-x}}{1+e^{-x}} \\

= \frac{1}{1+e^{-x}} * (\frac{1+e^{-x}}{1+e^{-x}} - \frac{1}{1+e^{-x}})\\

= \frac{1}{1+e^{-x}} * ( 1 - \frac{1}{1+e^{-x}})

3. Tanh-Funktion

#Tanh-Funktion
def tanh(x):
    return (np.exp(x) -np.exp(-x)) / (np.exp(x) + np.exp(-x))

#Differenzierung der Tanh-Funktion
def tanh_d(x):
    return 1- ( (np.exp(x) -np.exp(-x)) / (np.exp(x) + np.exp(-x)) )**2

#Grafikanzeige
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, tanh(x), label='tanh')
plt.plot(x, tanh_d(x), label='tanh_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Tanh-Funktion: **

tanh(x) = \frac{e^x-e^{-x}}{e^x+e^{-x}}

** Differenzierung der Tanh-Funktion: **

tanh(x) = \frac{4}{(e^x + e^{-x})^2}\\

Die Tanh-Funktion wurde als verbesserte Version der Sigmoid-Funktion verwendet (der Maximalwert bei Differenzierung ist höher als bei Sigmoid), aber das grundlegende Problem, dass y mit zunehmendem x bei 1 bleibt, wurde nicht verbessert. ..

** Ableitung der Differenzierung der Tanh-Funktion **

Differenzierungsformel des Quotienten(\frac{f(x)}{g(x)})' = \frac{f'(x)*g(x) - f(x)*g'(x)}{g(x)^2}Mit\\

tanh'(x) = \frac{(e^x+e^{-x})^2 - (e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= \frac{e^{2x}+2+e^{-2x} - (e^{2x} -2 + e^{-2x})}{(e^x + e^{-x})^2}\\

= \frac{4}{(e^x + e^{-x})^2}\\

Oder

tanh'(x) = \frac{(e^x+e^{-x})^2 - (e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= 1 - \frac{(e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= 1 - (\frac{e^x - e^{-x}}{e^x + e^{-x}})^2\\

4. ReLU-Funktion

#ReLU-Funktion
def relu(x):
    return np.maximum(0, x)

#Differenzierung der ReLU-Funktion
def relu_d(x):
    return np.array(x > 0, dtype=np.int)

#Grafikanzeige
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, relu(x), label='relu')
plt.plot(x, relu_d(x), label='relu_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** ReLU-Funktion: **

** Differenzierung der ReLU-Funktion: **

Die ReLU-Funktion wurde erstellt, um das grundlegende Problem der Sigmoid-Funktion zu beseitigen. Selbst wenn x zunimmt, nimmt y auch proportional zu, und wenn es immer differenziert wird, bleibt ein konstanter Term erhalten. Wenn ich jetzt etwas höre, scheint es natürlich, aber es wurde erst um 2012 verwendet.

Professor Yutaka Matsuo von der Universität Tokio sagte, dass die Sigmoid-Funktion eine schöne Funktion für Ingenieure aus Wissenschaft und Technik sei, da sie einfach sei und ihre Form sich selbst bei Differenzierung kaum ändere. Auf der anderen Seite war ReLU nicht cool und es gab einen Punkt, an dem es bei (0,0) nicht unterschieden werden konnte, so dass niemand es verwenden wollte.

Früher funktionierte Deep Learning nicht gut, daher verwendeten alle die schöne Sigmoid-Funktion als Ausdruck. Nachdem einige Leute es bewegen konnten, versuchten sie verschiedene Dinge, und es wird gesagt, dass ReLU in einer solchen Situation eingesetzt wurde.

5. Undichte ReLU-Funktion

#Undichte ReLU-Funktion
def leaky_relu(x):
    return np.where(x > 0, x , 0.01 * x)

#Differenzierung der Leaky ReLU-Funktion
def leaky_relu_d(x):
    return np.where(x>0,1,0.01)

#Grafikanzeige
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, leaky_relu(x), label='leaky_relu')
plt.plot(x, leaky_relu_d(x), label='leaky_relu_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Undichte ReLU-Funktion: ** ** Differenzierung der Leaky ReLU-Funktion: **

Die Leaky ReLU-Funktion ist von der ReLU-Funktion abgeleitet und hat einen Gradienten von 0,01x, selbst wenn x 0 oder weniger ist. Es wurde erwartet, dass die Optimierung weiter fortgeschritten ist als die ReLU-Funktion, aber es scheint ziemlich begrenzt zu sein, wenn die Optimierung besser als die ReLU-Funktion funktioniert.

6. Erleben Sie den Unterschied in der Leistung der Aktivierungsfunktion

Lassen Sie uns abschließend feststellen, wie stark sich die Optimierungsleistung je nach Aktivierungsfunktion unterscheidet.

[TensorFlow PlayGround](http://playground.tensorflow.org/#activation=relu&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=3,3&seed=0.343f True & xTimesY = false & xSquared = false & ySquared = false & cosX = false & sinX = false & cosy = false & sinY = false & collectStats = false & problem = Klassifizierung & initZero = false & hideText = false)

Lassen Sie uns die Konvergenzzeit überprüfen, indem Sie mit diesen drei Neuronen ein zweischichtiges neuronales Netzwerk einrichten und die Aktivierung (Aktivierungsfunktion) im roten Rahmen umschalten.

Es gibt einige probabilistische Probleme, aber es gibt einige Variationen, aber die Konvergenzzeit ist für Tanh ungefähr 10-mal schneller als für Sigmoid und für ReLU ungefähr 2-mal schneller als für Tanh.