Der Gradientenabstieg in Python

Der Gradientenabstieg ist ein Algorithmus, der uns hilft, den Mindestfehler zu finden oder bei dem der Verlustwert geringer ist. Wir wählen einen beliebigen Punkt in der Funktion und bewegen sich dann langsam in die negative Richtung, damit wir den Mindestfehler erreichen können. Aber während sich bewegen, kümmern wir uns auch um den Fehlerwert, der den Wert ist, der von den Vorhersage und Wahrheitswert abgezogen wird. Außerdem sollte es nicht negativ werden.

Wir können es aus dem folgenden Beispiel besser verstehen:

Nehmen wir an, eine Maschine wandelt die Kilometer auf Meilen um.

Aber wir haben nicht die Formel, die Kilometer in Meilen umzuwandeln. Wir wissen, dass beide Werte linear sind, was bedeutet.

Die Formel wird so dargestellt:

Meilen = Kilometer * C

Hier ist C eine Konstante, und wir kennen den genauen Wert der Konstante nicht.

Wir haben einen universellen Wahrheitswert als Hinweis. Die Wahrheitstabelle ist unten angegeben:

Wir werden jetzt einen zufälligen Wert von C verwenden und das Ergebnis bestimmen.

Wir verwenden also den Wert von C als 0.5, und der Wert der Kilometer beträgt 100. Das gibt uns 50 als Antwort. Wie wir sehr gut wissen, sollte der Wert nach der Wahrheitstabelle 62 betragen.137. Der Fehler, den wir also unten finden müssen:

Fehler = Wahrheit - berechnet

= 62.137 - 50

= 12.137

Auf die gleiche Weise können wir das Ergebnis im Bild unten sehen:

Jetzt haben wir einen Fehler von 12.137. Wie bereits erwähnt, ist die Beziehung zwischen Meilen und Kilometern linear. Wenn wir also den Wert der Zufallskonstante C erhöhen, werden wir möglicherweise weniger Fehler bekommen.

Diesmal ändern wir nur den Wert von c aus 0.5 bis 0.6 und erreichen Sie den Fehlerwert von 2.137, wie im Bild unten gezeigt:

Jetzt verbessert sich unsere Fehlerrate gegenüber 12.317 bis 2.137. Wir können den Fehler noch verbessern, indem wir mehr Vermutungen zum Wert von C verwenden. Wir vermuten, dass der Wert von C 0 sein wird.6 bis 0.7, und wir erreichten den Ausgangsfehler von -7.863.

Diesmal überquert der Fehler die Wahrheitstabelle und den tatsächlichen Wert. Dann überqueren wir den Mindestfehler. Aus dem Fehler können wir also sagen, dass unser Ergebnis von 0.6 (Fehler = 2.137) war besser als 0.7 (Fehler = -7.863).

Warum haben wir es nicht mit den kleinen Veränderungen oder Lernrate des konstanten Wertes von C versucht? Wir werden nur den C -Wert von 0 ändern.6 bis 0.61, nicht bis 0.7.

Der Wert von c = 0.61 gibt uns einen geringeren Fehler von 1.137, was besser ist als die 0.6 (Fehler = 2.137).

Jetzt haben wir den Wert von C, das ist 0.61, und es gibt einen Fehler von 1.137 nur aus dem richtigen Wert von 62.137.

Dies ist der Algorithmus zum Abstiegsabstieg, der den Mindestfehler herausfindet.

Python -Code:

Wir konvertieren das obige Szenario in Python -Programmierung. Wir initialisieren alle Variablen, die wir für dieses Python -Programm benötigen. Wir definieren auch die Methode kilo_mile, wo wir einen Parameter C (Konstante) übergeben.

Im folgenden Code definieren wir nur die Stoppbedingungen und die maximale Iteration. Wie bereits erwähnt, wird der Code entweder angehalten, wenn die maximale Iteration erreicht wurde oder der Fehlerwert größer als die Genauigkeit. Infolgedessen erreicht der konstante Wert automatisch den Wert von 0.6213, der einen geringfügigen Fehler hat. Unsere Gradientenabstieg wird also auch so funktionieren.

Gradientenabstieg in Python

Wir importieren die erforderlichen Pakete und zusammen mit den integrierten Sklearn-Datensätzen. Dann setzen wir die Lernrate und mehrere Iterationen, wie unten im Bild gezeigt:

Wir haben die Sigmoidfunktion im obigen Bild gezeigt. Jetzt konvertieren wir das in eine mathematische Form, wie im folgenden Bild gezeigt. Wir importieren auch den integrierten sklearn-Datensatz, der zwei Funktionen und zwei Zentren enthält.

Jetzt können wir die Werte von x und Form sehen. Die Form zeigt, dass die Gesamtzahl der Zeilen 1000 beträgt und die beiden Spalten, wie wir zuvor festgelegt haben.

Wir fügen am Ende jeder Zeile X eine Spalte hinzu, um die Verzerrung als trainierbarer Wert zu verwenden, wie unten gezeigt. Jetzt beträgt die Form von x 1000 Zeilen und drei Spalten.

Wir fordern auch das y um und jetzt haben es 1000 Zeilen und eine Spalte, wie unten gezeigt:

Wir definieren die Gewichtsmatrix auch mit Hilfe der Form des X, wie unten gezeigt:

Jetzt haben wir die Ableitung des Sigmoids erstellt und angenommen, dass der Wert von x nach dem Durchlaufen der Sigmoid -Aktivierungsfunktion, die wir zuvor gezeigt haben.

Dann werden wir bis zur Anzahl der Iterationen, die wir bereits festgelegt haben. Wir finden die Vorhersagen heraus, nachdem wir die Sigmoid -Aktivierungsfunktionen durchlaufen haben. Wir berechnen den Fehler und berechnen den Gradienten, um die Gewichte wie unten im Code gezeigt zu aktualisieren. Wir speichern auch den Verlust in jeder Epoche in der Verlaufsliste, um den Verlustdiagramm anzuzeigen.

Jetzt können wir sie in jeder Epoche sehen. Der Fehler nimmt ab.

Jetzt können wir sehen, dass sich der Fehlerwert kontinuierlich verringert. Dies ist also ein Algorithmus zum Abstiegsabstieg.