Simulation de Deep Learning / Probabilistic Gradient Descente (SGD)

1.Tout d'abord

J'ai commencé l'apprentissage profond. Cette fois, simulons ** Probabilistic Gradient Descent (SGD) avec Jupyter Notebook. ** **

La méthode de descente de gradient simple calcule la pente à partir de toutes les données et met à jour les poids, donc une fois que vous tombez dans une solution locale, il devient difficile d'en sortir et le calcul prend du temps. 　 La méthode de descente de gradient probabiliste (SGD) extrait au hasard une partie des données, calcule la pente et met à jour le poids. C'est plus facile et moins long à calculer.

J'ai trouvé très intéressant que ce ** flou bâclé soit un moyen d'atteindre une solution plus optimale **, donc cette fois je voudrais simuler la méthode de descente de gradient stochastique (SGD) avec Jupyter Notebook. pense.

2. Création de données

Cette fois, par souci de simplicité, nous n'utiliserons qu'un seul poids. Prenez 11 points de coordonnées x et y et faites une approximation avec un polypole à 6 dimensions.

import numpy as np
import matplotlib.pyplot as plt

#Données (pour créer des polynômes)
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])

#Création polymère (6 dimensions)
p = np.poly1d(np.polyfit(x, y, 6))
print(p)

#Afficher les données et les polynômes
xp = np.linspace(-10, 10, 100)
plt.plot(x, y, '.', xp, p(xp), '')
plt.xlim(-7, 7)
plt.ylim(-5, 10)
plt.show()

Sur la base du polymorphisme obtenu, trouvez y lorsque x est divisé en 100 parties de -10 à 10 et changé. En réalité, la valeur observée doit être bruyante, nous ajoutons donc un nombre aléatoire de 0 à 0,2 à y.

#Créez 100 points de données à partir du polypoly (0 à 0).Ajouter 2 nombres aléatoires)
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)) 

#Afficher les données créées
plt.scatter(x_add, y_add, alpha=0.5)
plt.xlim(-7, 7)
plt.ylim(-5, 10)
plt.show()

Nous avons créé des données (100 points) avec une solution locale autour de x = -4, 4 et une solution optimale autour de x = 0.

3. Méthode de descente de gradient probabiliste

C'est la partie principale du code. Utilisez train_test_split pour échantillonner au hasard 10 points à partir de 100 points de données.

Basé uniquement sur les données des 10 points, approximer avec un polypole à 6 dimensions, trouver la différenciation avec d_y = p.deriv (), calculer la pente et mettre à jour le poids.

Faites-le un écran à la fois et animez-le avec une animation matplotlib.

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

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

#Fonction d'échantillonnage aléatoire (échantillonnage de 100 à 10 points)
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 fonction de création d'écran
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

#Fonction de création d'animation
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

Maintenant, exécutons la simulation avec le taux d'apprentissage alpha = 0,3 et le poids initial x = 3,5.

#Taux d'apprentissage 0.3, valeur initiale du poids 3.Courir en 5
gradient_descent(alpha=0.3, w=np.array([3.5]))  

Lorsque vous exécutez le code, l'affichage suivant apparaîtra, veuillez donc le lire avec le bouton ▶ ︎. C'est probabiliste, donc cela peut ne pas fonctionner, mais si vous l'essayez plusieurs fois, vous verrez quelque chose de bâclé. Il est intéressant de jouer avec différents paramètres.

Voici un exemple de son fonctionnement (taux d'apprentissage alpha = 0,3, poids initial X = 3,5, lecture en boucle). Avec un bon calcul de pente bâclée, nous sommes arrivés à la solution optimale X = 0, pas seulement à la solution locale X = 4.