Der Zweck hier ist, zu interpretieren, was ich nicht verstehen konnte, indem ich ein Buch las, während ich Deep Learning studierte, und mich reibungslos daran zu erinnern, wenn ich später darauf zurückblicke. Ich werde den Inhalt des Codes so sorgfältig wie möglich erklären und hoffe, dass er hilfreich ist.
Vorheriger Artikel: Zusammenfassung Hinweis zu Deep Learning -4.2 Loss Function- Wie erläutert, besteht der Zweck des Lernens eines neuronalen Netzwerks jedoch darin, nach den optimalen Parametern zu suchen und den Wert der Verlustfunktion zu verringern. Wie aktualisieren Sie speziell die Parameter? Als Methode wird die diesmal erläuterte Gradientenmethode verwendet.
Zunächst werde ich kurz beschreiben, wie die Gradientenmethode abläuft.
Bei der Gradientenmethode unterscheidet sich der Name je nachdem, ob der Minimalwert oder der Maximalwert ermittelt werden soll. Ersteres ist ** Gradienten anständige Methode **, Letzteres ist die ** Gradientenaufstiegsmethode Namens. Dieses Mal werde ich als Beispiel die ** Gradientenabstiegsmethode ** </ font> erläutern, die häufig in neuronalen Netzen vorkommt.
Die Formel der Gradientenmethode lautet wie folgt
x = x -n\frac{\partial f}{\partial x}
Angezeigt durch. Wie Sie der Formel entnehmen können, wird die Funktion f (x) in Bezug auf x differenziert, um die Steigung zu erhalten. Multiplizieren Sie dies mit n und subtrahieren Sie vom aktuellen Punkt, um den Punkt zu aktualisieren. Wenn die Steigung der Funktion f (x) 0 wird, wird der Differenzwert 0 und die Parameter werden nicht aktualisiert.
n wird als Lernrate bezeichnet. Dies ist der Betrag, der bestimmt, wie stark der Parameter bei jedem Lernen aktualisiert wird. Je größer der Wert ist, desto länger ist die Bewegungsentfernung des Parameters jedes Mal, und je kleiner der Wert ist, desto kürzer ist die Bewegungsentfernung. Bitte beachten Sie, dass ** "Die Lernrate muss einen geeigneten Wert verwenden" ** </ font>, der später erläutert wird.
In diesem Beispiel die Funktion
f(x_1,x_2) = x_0^2 + x_1^2
Suchen wir nach x1, x2, das den Wert von f (x1, x2) durch die Gradientenmethode minimiert.
#Modulimport
import numpy as np
#Definieren Sie eine zu differenzierende Funktion
def numerical_gradient(function,x):
h = 1e-4
#Erstellen Sie ein Array mit der gleichen Form wie x und allen 0 Elementen
#Ersetzen Sie den differenzierten Wert später
grad = np.zeros_like(x)
for idx in range(x.size):
tmp_val = x[idx]
#f(x+h)
x[idx] = tmp_val + h
fxh1 = function(x)
#f(x-h)
x[idx] = tmp_val -h
fxh2 = function(x)
#Differenzieren und grad einen Wert zuweisen
grad[idx] = (fxh1 - fxh2)/(2*h)
#Machen Sie den Wert von x rückgängig
x[idx] = tmp_val
#Gibt grad zurück, wenn alle x unterschieden werden können
return grad
#Definieren Sie eine Funktion der Gradientenabstiegsmethode(Diesmal main)############################
def gradient_descent(function,init_x,lr=0.01,step_num=100):
#lr ist die Lernrate, Schritt_num ist die Anzahl der Male. Hier ist Standard jeweils 0.01、100
#x ist der aktuelle Ort (Array)
x = init_x
#step_Aktualisieren Sie die Punktnummern.
for i in range(step_num):
grad = numerical_gradient(function,x)
#Verlaufsformel
x = x - lr * grad
#step_Geben Sie den Punkt nach dem num-Aktualisieren aus
return x
############################################################
#Erstellen Sie eine Funktion zum Testen
def testfunction(x):
return x[0]**2 + x[1]**2
#Erstellen Sie x für den Test
testx = np.array([3,2])
#Führen Sie die Gradientenmethode mit dem Anfangspunkt von x durch(init_x), Lernrate(lr)Anzahl des Lernens(step_num)Der Satz
gradient_descent(testfunction,init_x=testx,lr=0.1,step_num=100)
Das Ausgabeergebnis ist
array([-6.35809854e-07, -3.81434987e-07])
Es wurde. Es ist schwer zu verstehen, weil es e enthält, aber mit anderen Worten,
x_1 = -6.358 ×10^{-7} = - 0.0000006358 \\
x_2 = -3.814 ×10^{-7} = - 0.0000003814
Ist. Dies ist ein Wert nahe (x1, x2) = (0,0), und man kann sagen, dass mit der Gradientenmethode nahezu korrekte Ergebnisse erzielt wurden.
Die Lernrate sollte nicht zu groß oder zu klein sein. Lassen Sie uns den Grund dafür mit dem oben geschriebenen Code überprüfen.
Wenn die Lernrate zu hoch ist
Versuchen Sie, lr im Code von 0,1 auf 1 zu ändern. Das Ausführungsergebnis ist wie folgt
array([-2499150084997, -1499450054998])
Dies ist weit entfernt von (x1, x2) = (0,0).
Der Grund ist, dass bei zu hoher Lernrate die Werte abweichen können.
Wenn die Lernrate zu gering ist
Versuchen Sie, den Code lr von 0,1 auf 0,000001 zu ändern. Das Ausführungsergebnis ist wie folgt
array([2.97441101, 1.98460701])
Dies ist auch weit entfernt von (x1, x2) = (0,0).
Der Grund dafür ist, dass der Wert in einem Lernprogramm kaum aktualisiert wurde und in step_num-Zeiten kein ausreichendes Lernen durchgeführt wurde.
[Deep Learning von Grund auf neu und Theorie des mit Python (Japanisch) erlernten Deep Learning](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81] % 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8BTiefenlernen-% E2% 80% 95Python% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0% E3% 81% AE% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% A3% 85-% E6% 96% 8E% E8% 97% A4 -% E5% BA% B7% E6% AF% 85 / dp / 4873117585 / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82% AB% E3% 83% 8A & crid = W6DVSLVW0BUS & dchild = 1 & keywords =% E3% 82% BC% E3% 83% AD% E3% 81% 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8Bdeep + learning & qid = 1597943190 & sprefix =% E3% 82% BC % E3% 83% AD% E3% 81% 8B% E3% 82% 89% 2Caps% 2C285 & sr = 8-1)]
OS: Windows 10/Ubuntu 20.04 LTS Jupyter Notebook Python Version: Python 3.8
Recommended Posts