[PYTHON] Deep Learning / SGD-Simulation (Probabilistic Gradient Descent)

1. Zuallererst

Ich begann tief zu lernen. Dieses Mal simulieren wir ** Probabilistic Gradient Descent (SGD) mit Jupyter Notebook. ** **.

Die einfache Gradientenabstiegsmethode berechnet die Steigung aus allen Daten und aktualisiert die Gewichte. Wenn Sie also in eine lokale Lösung fallen, wird es schwierig, sie zu verlassen, und die Berechnung dauert einige Zeit. 　 Die probabilistische Gradientenabstiegsmethode (SGD) extrahiert zufällig einen Teil der Daten, berechnet die Steigung und aktualisiert das Gewicht, sodass die Steigungsberechnung gut schwankt und die lokale Lösung überwindet, um die optimalere Lösung zu erreichen. Die Berechnung ist einfacher und weniger zeitaufwändig.

Ich fand es sehr interessant, dass diese ** schlampige Unschärfe ein Mittel ist, um eine optimalere Lösung zu erreichen **, daher möchte ich dieses Mal die stochastische Gradientenabstiegsmethode (SGD) mit Jupyter Notebook simulieren. Überlegen.

2. Datenerstellung

Dieses Mal werden wir der Einfachheit halber ein Gewicht verwenden. Nehmen Sie 11 Punkte mit x- und y-Koordinaten und approximieren Sie mit einem 6-dimensionalen Polypoly.

import numpy as np
import matplotlib.pyplot as plt

#Daten (zum Erstellen von Polynomen)
x = np.array([-5.0,  -4.0,  -3.0,  -2.0,  -1.0,   0.0,   1.0,   2.0,   3.0,   4.0,    5.0])
y = np.array([ 5.0,   1.5,   2.0,   1.5,   0.0,  -3.0,  -1.0,   2.0,   3.0,   2.5,    5.0])

#Polymererzeugung (6 Dimensionen)
p = np.poly1d(np.polyfit(x, y, 6))
print(p)

#Daten und Polynome anzeigen
xp = np.linspace(-10, 10, 100)
plt.plot(x, y, '.', xp, p(xp), '')
plt.xlim(-7, 7)
plt.ylim(-5, 10)
plt.show()

Finden Sie basierend auf dem erhaltenen Polymorphismus y, wenn x in 100 Teile von -10 bis 10 geteilt und geändert wird. In der Realität sollte der beobachtete Wert verrauscht sein, daher addieren wir eine Zufallszahl von 0 bis 0,2 zu y.

#Erstellen Sie 100 Datenpunkte aus Polypoly (0 bis 0).2 Zufallszahlen hinzufügen)
x_add, y_add =[], []
for i in np.linspace(-10, 10, 100):
    x_add.append(i)
    y_add.append( p(i) + np.random.normal(0, 0.2)) 

#Zeigen Sie die erstellten Daten an
plt.scatter(x_add, y_add, alpha=0.5)
plt.xlim(-7, 7)
plt.ylim(-5, 10)
plt.show()

Wir haben Daten (100 Punkte) mit einer lokalen Lösung um x = -4, 4 und einer optimalen Lösung um x = 0 erstellt.

3. Probabilistische Gradientenabstiegsmethode

Dies ist der Hauptteil des Codes. Verwenden Sie train_test_split, um 10 Punkte aus 100 Datenpunkten zufällig abzutasten.

Basierend nur auf den Daten der 10 Punkte, ungefähr mit einem 6-dimensionalen Polypoly, finden Sie die Differenzierung mit d_y = p.deriv (), berechnen Sie die Steigung und aktualisieren Sie das Gewicht.

Führen Sie diesen Bildschirm einzeln aus und animieren Sie ihn mit einer Matplotlib-Animation.

from sklearn.model_selection import train_test_split
from matplotlib import pylab
from matplotlib import animation, rc

#Aufbau
rc('animation', html='jshtml')
w = np.array([-2.])

#Zufallsstichprobenfunktion (Abtastung 100 bis 10 Punkte)
def random_sampling():
    X_train, X_test, y_train, y_test = train_test_split(x_add, y_add, test_size=0.90)
    _x = X_train
    _y = y_train 
    return _x, _y

#1 Bildschirmerstellungsfunktion
def animate(frame, w, alpha):    
    _x, _y = random_sampling()
    p = np.poly1d(np.polyfit(_x, _y, 6))
    plt.plot(_x, _y, '.',
             xp, p(xp), '')
    d_y = p.deriv()
    
    plt.clf()
    plt.plot(xp, p(xp), '-', color='green')
    plt.plot(w, p(w), '.', color='red', markersize=20)
    plt.xlim(-7, 7)
    plt.ylim(-5, 10)  
    
    grad = d_y(w)
    w -= alpha * grad

#Animationserstellungsfunktion
def gradient_descent(alpha, w):
    fig, ax = plt.subplots(111)
    if type(w) is list:
        w = np.array(w, detype=np.float32)
    anim = animation.FuncAnimation(fig, animate, fargs=(w, alpha), frames=100, interval=300) 
    
    return anim

4. Simulation

Lassen Sie uns nun die Simulation mit der Lernrate Alpha = 0,3 und dem Anfangsgewicht x = 3,5 ausführen.

#Lernrate 0.3, Anfangswert des Gewichts 3.Laufen Sie in 5
gradient_descent(alpha=0.3, w=np.array([3.5]))  

Wenn Sie den Code ausführen, wird die folgende Anzeige angezeigt. Spielen Sie ihn daher bitte mit der Taste ▶ ︎ ab. Es ist wahrscheinlich, daher funktioniert es möglicherweise nicht, aber wenn Sie es ein paar Mal versuchen, werden Sie etwas Schlampiges sehen. Es ist interessant, mit verschiedenen Parametern zu spielen.

Hier ist ein Beispiel, wie es funktioniert hat (Lernrate Alpha = 0,3, Anfangsgewicht X = 3,5, Loop-Wiedergabe). Mit einer guten Sloppy-Tilt-Berechnung haben wir die optimale Lösung X = 0 erreicht, nicht nur die lokale Lösung X = 4.