tout le monde premier souhaite une bonne mi-automne ~
Le modèle réel dans le processus de formation, en particulier dans l'apprentissage en profondeur, le paramètre atteindra des dizaines de millions, l'espace des paramètres deviendra très grand. Pour mieux vous aider à comprendre l'algorithme d'optimisation, nous commencerons par une unidimensionnelle fonction de perte, lors de la présentation du code, je ne vais pas montrer les coordonnées de déclin, non seulement à cause d'un coordinat descente et mises à jour basées sur les gradients sont dans le même direction de la recherche, plus important encore, ce chapitre de code espoir que nous pouvons saisir le tirage au sort et de visualiser une image GIF dans cette section algorithme d'optimisation, qui est largement utilisé dans nos leçons ultérieures.
Nous assumons la fonction de perte pour le paramètre est une fonction quadratique très simple:
Ensuite, son gradient est:
def f (x):
retour (X ** 2)
def df (x):
retour (2 * x)
Selon le même temps sur un des articles théoriques ladite équation de descente de gradient:
Nous pouvons définir une fonction pour une descente de gradient, qui prend la valeur initiale et les paramètres de taux d'apprentissage, les valeurs de retour et les valeurs des paramètres Perte après chaque mise à jour, on note que, à ce moment seulement itération 100 fois:
def GD (de gauche à droite, début):
x = début
GD_x, GD_y = ,
pour elle en plage (100):
GD_x.append (x)
GD_y.append (f (x))
dx = df (x)
x = x - lr * dx
retour (GD_x, GD_y)
En utilisation réelle, on n'a pas besoin d'enregistrer les résultats de chaque itération, lorsque le paramètre très longtemps, la consommation de mémoire de l'ordinateur sera très grande, mais nous devons utiliser les résultats de chaque étape du processus pour vous montrer décliner visuellement. A propos du code beaucoup de gens peuvent comprendre rapidement et à l'application même, mais le processus de déclin du spectacle, nous avons besoin de dessiner la carte dynamique, nous devons utiliser matplotlib en animation, en plus, si nous devons sauver GIF, nous avons aussi besoin d'installer ffmpeg.
Code GIF dans la réalisation de fonctionnement pratique, nous devons dégager deux étapes:
- Ne sera pas mis à jour une partie graphique
- graphiques constamment mis à jour et une partie graphique de l'initialisation
Pour la première étape, on peut facilement écrire:
matplotlib.pyplot importation comme plt
Seaborn d'importation comme sns
sns.set (style = 'darkgrid')
FFwriter = animation.FFMpegWriter ()
fig, Ax = plt.subplots ()
fig.set_tight_layout (Vrai)
points_x = np.linspace (-20, 20, 1000)
points_y = f (points_x)
ax.plot (points_x, points_y, c = "k", alpha = 0,9, linestyle = "-")
Pour la deuxième étape, il faut d'abord obtenir les résultats de la descente de gradient:
GD_x, GD_y = GD (lr = pow (2, -10) * 16, start = -20)
Ensuite initialize, mettez à jour la définition d'une formule, nous obtiendrons les résultats afin de mettre à jour ce qui précède:
point_line, = ax.plot (GD_x , GD_y , 'ou')
def mise à jour (i):
étiquette 'timestep {0}' = format. (i)
impression (étiquette)
point_line.set_xdata (GD_x )
point_line.set_ydata (GD_y )
ax.set_xlabel (label)
retour point_line, hache
La figue, mise à jour FuncAnimation passé comme argument à la classe de notre animation, et définir le nombre d'images à 60 images, chaque intervalle de trame de 200 ms:
anim = FuncAnimation (fig, mise à jour, cadres = np.arange (0, 60), intervalle = 200)
Notre code se résume comme suit:
importer numpy comme np
matplotlib.pyplot importation comme plt
de l'animation d'importation matplotlib
de FuncAnimation import matplotlib.animation
Seaborn d'importation comme sns
sns.set (style = 'darkgrid')
FFwriter = animation.FFMpegWriter ()
fig, Ax = plt.subplots ()
fig.set_tight_layout (Vrai)
def f (x):
retour (X ** 2)
def df (x):
retour (2 * x)
points_x = np.linspace (-20, 20, 1000)
points_y = f (points_x)
ax.plot (points_x, points_y, c = "k", alpha = 0,9, linestyle = "-")
def GD (de gauche à droite, début):
x = début
GD_x, GD_y = ,
pour elle en plage (100):
GD_x.append (x)
GD_y.append (f (x))
dx = df (x)
x = x - lr * dx
retour (GD_x, GD_y)
GD_x, GD_y = GD (lr = pow (2, -10) * 16, start = -20)
print ( 'taille fig: {0} DPI, la taille en pouces {1} format' (.
fig.get_dpi (), fig.get_size_inches ()))
point_line, = ax.plot (GD_x , GD_y , 'ou')
def mise à jour (i):
étiquette 'timestep {0}' = format. (i)
impression (étiquette)
point_line.set_xdata (GD_x )
point_line.set_ydata (GD_y )
ax.set_xlabel (label)
retour point_line, hache
if__name __ == '__ main__':
anim = FuncAnimation (fig, mise à jour, des cadres = np.arange (0, 100), intervalle = 200)
anim.save ( 'GD.gif', écrivain = FFwriter)
Puis, comme le montre, nous avons réussi à réaliser la descente de gradient sur la fonction de perte, en même temps, on peut voir, le gradient de plus en plus petits, dans le cas de taux d'apprentissage fixe de déclin est devenu de plus en plus lent, itératives encore 60 fois il n'atteint pas le point le plus bas.
Nous pouvons essayer d'apprendre un peu de grands paramètres de taux, et voir si une itération plus rapide au minimum:
......
GD_x, GD_y = GD (lr = pow (2, -7) * 16, start = -20)
......
Si nous continuons à augmenter le taux d'apprendre ce qui se passe t-il? Nous continuons d'augmenter le taux d'apprentissage:
......
GD_x, GD_y = GD (lr = pow (2, -4) * 16, start = -20)
......
Comme le montre, lorsque le taux d'apprentissage continue d'augmenter lorsque les points de paramètres avant et en arrière à proximité du minimum de choc, imaginez, si nous continuons à augmenter le taux d'apprentissage, la mise à jour point au-delà de la portée du graphique.
essayer de temps à côté de la loi de Newton, besoin d'être au courant à ce moment de la fonction de perte de la dérivée seconde est une constante, si l'on utilise directement de la méthode de Newton de la formule de mise à jour:
Vous trouverez à cette époque de la méthode de Newton est juste un autre gradient de vitesse d'apprentissage à l'automne, le taux d'apprentissage est fixé à l'inverse de la dérivée seconde, nous voulons voir la différence dans la méthode de Newton et la méthode de descente de gradient, nous devons remplacer la fonction de perte, pour y parvenir, nous avons dû ajouter une petite fonction de perte trigonométriques articles:
avantage trigonométrique est qu'elle peut conduire non seulement d'ordre infini, et ne sera pas constante, mais pas beaucoup d'impact sur la forme de la fonction d'origine, on peut facilement écrire:
def f (x):
retour (-Np.cos (np.pi * x / 20) + x ** 2)
def df (x):
retour (Np.sin (np.pi * x / 20) * np.pi / 20 + 2 * x)
def DDF (x):
retour ((Np.pi / 20) ** 2 * np.cos (np.pi * x / 20) 2)
Cela garantit que la dérivée seconde est pas une constante, nous construisons à jour Newton Méthode:
def Newton (début):
x = début
Newton_x, Newton_y = ,
pour elle en plage (100):
Newton_x.append (x), Newton_y.append (f (x))
g = df (x)
h = DDF (x)
x = x -g / h
retour (Newton_x, Newton_y)
Nous utilisons ensuite cette fonction pour obtenir le point de mise à jour et mise à jour du GIF:
......
newton_x, newton_y = Newton (start = -20)
point_line, = ax.plot (newton_x , newton_y , 'ou')
def mise à jour (i):
étiquette 'timestep {0}' = format. (i)
impression (étiquette)
point_line.set_xdata (newton_x )
point_line.set_ydata (newton_y )
ax.set_xlabel (label)
retour point_line, hache
......
La méthode de Newton semble rapide, mais nous utilisons rarement dans le cas de la nature peu claire de la fonction de perte, en particulier dans l'étude approfondie, non seulement en raison de la nécessité pour les besoins de chaque étape à calculer hessois, mais aussi parce que si nous voulons vraiment Newton méthode étape de goutte d'exécution, doit veiller à ce que la définie positive hessois qui n'est pas établi dans certains cas, par exemple, nous avons directement fonction de perte est définie en fonction cosinus:
Notre valeur de paramètre initial est réglé sur -15, -20, car lorsque le temps juste maxima, le gradient est nul, ne peut pas être itérative, alors que le nombre d'image est réglée sur 10, nous examinons ce gain de temps:
def f (x):
retour (-Np.cos (np.pi * x / 20))
def df (x):
retour (Np.sin (np.pi * x / 20) * np.pi / 20)
def DDF (x):
retour ((Np.pi / 20) ** 2 * np.cos (np.pi * x / 20))
Comme on le voit, la méthode de Newton est réalisée à la place de l'augmentation de pas, parce que ce temps est Hessian définie négative, le cas unidimensionnel, la dérivée seconde est négative, le point de vue gradient formule de mise à jour méthode de Newton, le négatif défini Hessian lorsque le taux d'apprentissage est négatif.
Mais la descente de gradient n'a pas eu ce problème, parce que nous sommes dans la mise en uvre d'une descente de gradient, le taux d'apprentissage est toujours positif.
Comment résoudre le problème de la méthode de Newton au lieu de descendre il? On peut imiter la régression Ridge ajoutant régularisation L2 des façons de rendre la matrice échantillon pour forcer rang plein, même, nous pouvons également ajouter un terme de régularisation dans hessois, Jute forcé de faire précis:
Le code peut facilement être écrit:
def Newton (début, alpha):
x = début
Newton_x, Newton_y = ,
pour elle en plage (100):
Newton_x.append (x), Newton_y.append (f (x))
g = df (x)
h = DDF (x)
x = x -g / (h + alpha)
retour (Newton_x, Newton_y)
Nous avons mis le paramètre de régularisation alpha, et appliqué dans ce cas la fonction de perte:
......
Newton_x, Newton_y = Newton (start = -15, alpha = pow (2, -8) * 20)
......
Lors de l'utilisation matplotlib sauver l'image, même si le ffmpeg installé (ajouté à la variable d'environnement), il est encore possible problème d'économie d'erreur GIF se produit, il est recommandé de sauvegarder premier enregistrement du fichier MP4, puis exécutez la commande suivante dans le répertoire courant, qui est, GIF carte disponible:
ffmpeg.exe -i. \ filename.mp4filename.gif
Fonction de perte utilisée dans le présent document est simple, le processus réel, nous pouvons également faire face à un minimum global et des problèmes minimums locaux, mais dans une étude approfondie, l'optimisation convexe est pas un gros problème, parce que nous avons besoin que faire erreur de généralisation à trouver nous acceptons le degré, mais l'algorithme d'optimisation globale en théorie et actuellement il n'y a aucune garantie fiable.
En plus de la capacité d'adaptation du taux d'apprentissage et la fonction de perte, la valeur initiale du paramètre et le point selle est un problème très gênant dans le processus d'optimisation, le plus gros problème est que la loi de Newton sont généralement le point selle il trouve, nous allons nous concentrer dans le chapitre suivant pour expliquer au hasard descente de gradient en tant que représentant de la série de la technologie populaire, et il impliquera l'algorithme d'optimisation de la direction de la recherche du problème (dans cette section est seulement un paramètre unidimensionnel, la section suivante de l'article sera étendu aux codes multidimensionnels).
