Aujourd'hui est le dernier jour avant la fête nationale. apprendre sérieusement cette leçon, puis embrasser vacances mieux il ~ ~
Nous sur une « descente de gradient compréhension (a) les articles du Code » a vu l'impact des algorithmes d'optimisation des taux d'apprentissage, ainsi qu'une brève discussion sur les limites de la méthode de Newton, l'introduction de la méthode de Newton régularisé qui ne fonctionne pas mettre à jour la mauvaise direction, mais nous ne sommes qu'une seule dimension de la fonction de perte, direction optimisée que dans une direction fixe, mais dans l'espace de grande dimension, descente de gradient en raison de déraisonnable et la valeur initiale morbide de l'hessois itération mettre à jour gaspillé errant autour du contour, ce qui est un problème commun de descente de gradient ordinaire.
Ici, nous ne montrerons pas la descente de gradient stochastique, descente de gradient stochastique est important, mais le besoin de données supplémentaires dans notre fonction de perte, nous faisons principalement ici dans l'exemple de programme, nous avons encore une continuation de la pratique, dirigera la fonction de perte en tant que paramètre fonction. Nous avons d'abord construit simple perte:
La perte dans ce cas est une structure de bol typique, la fonction de corrélation de code peut facilement être écrit:
def f (x, y):
retour x ** 2 + y 2 **
def partial_x (x):
retour 2 * x
def partial_y (y):
retour 2 * y
En même temps, l'espace des paramètres gradient deviendra un espace vectoriel à deux dimensions, la mise à jour gradient le code à écrire:
def GD (de gauche à droite, début):
x, y = Début , commencer
GD_x, GD_y, GD_z = , ,
pour elle en plage (100):
GD_x.append (x)
GD_y.append (y)
GD_z.append (f (x, y))
dx = partial_x (x)
dy = partial_y (y)
x = x - lr * dx
y = y - lr * dy
retour GD_x, GD_y, GD_z
Ici, j'ai enregistré une perte de valeur de l'enregistrement pour la visualisation de l'espace des paramètres est pas nécessaire, mais nous suivons le taux de convergence de la recherche est nécessaire, plus important encore, nous sommes dans la pratique ne peuvent souvent pas connaître l'exacte point de paramètre optimal, nous devons déterminer si la perte de changements dans le processus de formation est terminée.
Nous continuons sur un cadre de base, afin de célébrer la fête nationale, nous avons sélectionné est chaud colormap, encore plus chaud, animé et plein de passion:
importer numpy comme np
matplotlib.pyplot importation comme plt
de l'animation d'importation matplotlib
matplotlib.cm d'importation en cm
de FuncAnimation import matplotlib.animation
Seaborn d'importation comme sns
sns.set (style = 'blanc')
FFwriter = animation.FFMpegWriter ()
fig, Ax = plt.subplots ()
fig.set_tight_layout (Vrai)
def f (x, y):
retour x ** 2 + y 2 **
def partial_x (x):
retour 2 * x
def partial_y (y):
retour 2 * y
a = np.linspace (-20,20,100)
b = np.linspace (-20,20,100)
A, B = np.meshgrid (a, b)
ax.contourf (A, B, f (A, B), 50, alpha = 0,8, cmap = cm.hot) # dernier paramètre colormap
def GD (de gauche à droite, début):
x, y = Début , commencer
GD_x, GD_y, GD_z = , ,
pour elle en plage (100):
GD_x.append (x)
GD_y.append (y)
GD_z.append (f (x, y))
dx = partial_x (x)
dy = partial_y (y)
x = x - lr * dx
y = y - lr * dy
retour (GD_x, GD_y, GD_z)
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, start = )
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
si __name__ == '__main__':
anim = FuncAnimation (fig, mise à jour, cadres = np.arange (0, 15), intervalle = 200)
plt.show ()
Comme le montre, nous avons réalisé sur les deux dimensions algorithme d'optimisation de descente de gradient de l'espace des paramètres, plus la couleur, plus la valeur de la perte, qui a fixé le taux d'utilisation de notre apprentissage sur l'une d'expérience.
Nous pouvons mettre en uvre un algorithme simple basé sur la théorie de la dynamique:
def Momentum (de gauche à droite, a, commencer):
xy = début
v = np.array ()
M_xy, M_z = ,
pour elle en plage (100):
M_xy.append (xy)
M_z.append (f (xy , xy ))
v = a * v -
xy = xy + v
retour (M_xy, M_z)
Avis J'écris ce code n'est pas le temps de variable divisée, mais directement comme un tableau à la poignée, généralement dans les paramètres espace des paramètres de grande dimension recommandés comme vecteur pour paramètre de tableau de soustraction directe lors de la mise à jour nous faisons des ajustements précis aux paramètres correspondants d'une image de mouvement, le numéro de châssis est réglé sur 50, peuvent être obtenues:
Comme le montre, les paramètres de mise à jour itérative dans l'algorithme de mouvement est plus comme des particules dans la mécanique newtonienne, dérive heureux dans une zone en forme de bol, mais attention à un autre grand algorithme dynamique de l'élan et descente de gradient ne sera pas la même, descente de gradient produira un choc symétrique, l'algorithme de mouvement est un amortissement de choc, l'amplitude deviendra de plus en plus petit.
Nous pouvons régler les paramètres ultra-un, le rendre plus petit, parce que, selon l'analyse théorique, les étapes dans l'algorithme de mouvement devient:
un plus petit, plus l'accélération, est plus susceptible de se stabiliser à l'extrême, nous deviendrons un 0,9 de 0,4:
M_xy, M_z = Momentum (lr = pow (2, -7) * 16, a = 0,4, start = )
Comme le montre, la dynamique de déclin de gradient arithmétique pure beaucoup plus rapide, bien sûr, plus important encore, même lorsque la taille de l'étape, il ne produira pas une descente pure gradient de choc symétrique comme ça.
Ensuite, en raison des contraintes d'espace, nous sautons algorithme AdaGrad, construit directement algorithme RMSProp:
def RMSProp (de gauche à droite, d, ro, départ):
xy = début
r = np.array ()
RMS_xy, RMS_z = ,
pour elle en plage (100):
RMS_xy.append (xy)
RMS_z.append (f (xy , xy ))
g = np.array ( )
r = ro * r + (1-ro) * g * g
xy = xy - lr / (d + np.sqrt (r)) * g
retour (RMS_xy, RMS_z)
Notez que nous avons un taux d'apprentissage adaptatif point de départ du gradient, plus RMSProp peut s'attendre à commencer RMSProp doit être très lent, mais nous pouvons augmenter le taux d'apprentissage initial, plutôt que trop d'inquiétude au sujet du taux d'apprentissage est trop conséquences haute performance de faible gradient: lorsque la descente
GD_xy, GD_z = RMSProp (lr = pow (2, -2) * 16, d = 1e-6, ro = 0,9, start = )
Comme on le voit, RMSProp plus rapide pour atteindre le point cible, mais il faut souligner, trop taux d'apprentissage encore provoquer un choc, mais aussi à proximité d'une petite tendance à la hausse gradient, il y a une tendance à la baisse à proximité des grands gradients, en tout cas, nous sommes toujours confrontés au problème de la fixation du taux d'apprentissage initial, mais le taux de descente de gradient adaptatif algorithme d'apprentissage que l'intelligence pure un lot.
En plus de la valeur initiale du taux d'apprentissage, la valeur initiale du paramètre est également important que nous regardons un point de la situation un peu plus complexe, la fonction de perte est définie comme suit:
Nous pouvons trouver que (0,0) est le point d'un point de selle, la même chose, nous changeons le code:
def f (x, y):
retour x ** 2 ** 2-y
def partial_x (x, y):
retour 2 * x
def partial_y (y, x):
retour -2 * y
algorithme de descente de gradient répète les étapes ci-dessus, nous constatons que les valeurs initiales des paramètres d'une grande influence:
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, start = )
Comme le montre, nous allons définir la valeur initiale du paramètre et trouvé juste rester près du point selle, ce qui est évidemment pas une bonne optimisation.
Nous transporterons seul paramètre valeur initiale d'un petit peu:
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, start = )
Comme le montre, la valeur initiale du paramètre que nous venons déplacé un peu, nous pouvons continuer à optimiser fui le point selle, de sorte que la descente de gradient, le point selle est pas un problème difficile à résoudre dans l'ingénierie, mais pour le second ordre algorithme d'optimisation tels que la loi de Newton , en supposant nulle doute de trouver une valeur de gradient zéro, le point selle est fatale.
les algorithmes et les algorithmes ici Adam AdaGrad non représentés, laissant le lecteur à la conception, si vous avez vraiment maîtrisé ces algorithmes d'optimisation, le code, mais le problème est d'ajouter quelques paramètres.
Fonction de perte Dans le présent document est trop simple, pas tous se rendre compte de la pleine puissance de l'algorithme et le montant mobilisé algorithme RMSProp, en fait, a un certain nombre de conditions pathologiques et descente de gradient stochastique, la variance de l'estimation gradient grande dans le hessois leur avantage très clair que ces algorithmes d'optimisation sont largement utilisés dans l'apprentissage en profondeur, nous verrons leur pouvoir dans une leçon ultérieure (fonction de perte principalement en raison de la profondeur de l'apprentissage assez compliqué, les avantages de ces algorithmes était assez évident).
