Le but ici est d'interpréter ce que je ne pouvais pas comprendre simplement en lisant un livre tout en étudiant le Deep Learning, et de m'en souvenir en douceur lorsque j'y repenserai plus tard. J'expliquerai le contenu du code aussi soigneusement que possible, donc j'espère qu'il sera utile.
Article précédent: Note récapitulative sur le Deep Learning -4.2 Loss Function- Cependant, comme expliqué, le but de l'apprentissage d'un réseau de neurones est de rechercher les paramètres optimaux et de réduire la valeur de la fonction de perte. Alors, comment mettez-vous à jour spécifiquement les paramètres? En tant que méthode, la méthode du gradient expliquée cette fois est utilisée.
Tout d'abord, je décrirai brièvement le déroulement de ce qui est fait par la méthode du gradient.
Dans la méthode du dégradé, le nom diffère selon que le but est de trouver la valeur minimale ou la valeur maximale. La première est la ** méthode du gradient décent ** Cette dernière est ** méthode d'ascension de gradient Appelé. Cette fois, je vais vous expliquer en utilisant la ** méthode de descente de gradient ** </ font>, qui apparaît souvent dans les réseaux de neurones, à titre d'exemple.
La formule de la méthode du gradient est la suivante
x = x -n\frac{\partial f}{\partial x}
Indiqué par. Comme vous pouvez le voir dans la formule, la fonction f (x) est différenciée par rapport à x pour obtenir la pente. Multipliez cela par n et soustrayez le point actuel pour mettre à jour le point. Lorsque la pente de la fonction f (x) devient 0, la valeur différentielle devient 0 et les paramètres ne sont pas mis à jour.
n est appelé le taux d'apprentissage, qui est le montant qui détermine à quel point le paramètre est mis à jour dans chaque apprentissage. Plus la valeur est élevée, plus la distance de déplacement du paramètre est longue à chaque fois, et plus la valeur est petite, plus la distance de déplacement est courte. Veuillez noter que ** "Le taux d'apprentissage doit utiliser une valeur appropriée" ** </ font>, qui sera expliquée plus tard.
Dans cet exemple, la fonction
f(x_1,x_2) = x_0^2 + x_1^2
Cherchons x1, x2 qui minimise la valeur de f (x1, x2) par la méthode du gradient.
#Importation de module
import numpy as np
#Définir une fonction pour différencier
def numerical_gradient(function,x):
h = 1e-4
#Créer un tableau avec la même forme que x et tous les 0 éléments
#Remplacez la valeur différenciée plus tard
grad = np.zeros_like(x)
for idx in range(x.size):
tmp_val = x[idx]
#f(x+h)
x[idx] = tmp_val + h
fxh1 = function(x)
#f(x-h)
x[idx] = tmp_val -h
fxh2 = function(x)
#Différencier et attribuer une valeur au diplôme
grad[idx] = (fxh1 - fxh2)/(2*h)
#Annuler la valeur de x
x[idx] = tmp_val
#Renvoie grad si la différenciation est possible pour tous les x
return grad
#Définir une fonction de la méthode de descente de gradient(Cette fois principale)############################
def gradient_descent(function,init_x,lr=0.01,step_num=100):
#lr est le taux d'apprentissage, pas_num est le nombre de fois. Ici, la valeur par défaut est 0 pour chaque.01、100
#x est l'emplacement actuel (tableau)
x = init_x
#step_Mettez à jour le nombre de points.
for i in range(step_num):
grad = numerical_gradient(function,x)
#Formule de gradient
x = x - lr * grad
#step_Sortie du point après avoir mis à jour nombre de fois
return x
############################################################
#Créer une fonction pour tester
def testfunction(x):
return x[0]**2 + x[1]**2
#Créer x pour le test
testx = np.array([3,2])
#Effectuer la méthode du gradient, point initial de x(init_x), Taux d'apprentissage(lr), Nombre d'apprentissage(step_num)L'ensemble
gradient_descent(testfunction,init_x=testx,lr=0.1,step_num=100)
Le résultat de sortie est
array([-6.35809854e-07, -3.81434987e-07])
C'est devenu. C'est difficile à comprendre car il contient e, mais en d'autres termes,
x_1 = -6.358 ×10^{-7} = - 0.0000006358 \\
x_2 = -3.814 ×10^{-7} = - 0.0000003814
Est. Il s'agit d'une valeur proche de (x1, x2) = (0,0), et on peut dire que des résultats presque corrects ont été obtenus par la méthode du gradient.
Le taux d'apprentissage ne doit être ni trop élevé ni trop petit. Vérifions la raison de cela avec le code écrit ci-dessus.
--Si le taux d'apprentissage est trop élevé
Essayez de changer lr dans le code de 0,1 à 1. Le résultat de l'exécution est le suivant
array([-2499150084997, -1499450054998])
C'est loin de (x1, x2) = (0,0).
La raison en est que si le taux d'apprentissage est trop élevé, les valeurs peuvent diverger.
--Si le taux d'apprentissage est trop faible
Essayez de changer le code lr de 0,1 à 0,000001. Le résultat de l'exécution est le suivant
array([2.97441101, 1.98460701])
C'est également loin de (x1, x2) = (0,0).
La raison est que la valeur a été à peine mise à jour dans un apprentissage, et un apprentissage suffisant n'a pas été effectué dans les temps step_num.
[Deep Learning from scratch-Theory et implémentation du deep learning appris avec Python (japonais)](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81] % 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8BApprentissage en profondeur-% E2% 80% 95Python% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0% E3% 81% AE% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% A3% 85-% E6% 96% 8E% E8% 97% A4 -% E5% BA% B7% E6% AF% 85 / dp / 4873117585 / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82% AB% E3% 83% 8A & crid = W6DVSLVW0BUS & dchild = 1 & mots-clés =% E3% 82% BC% E3% 83% AD% E3% 81% 8B% E3% 82% 89% E4% BD% 9C% E3% 82% 8Bdeep + apprentissage & qid = 1597943190 & sprefix =% E3% 82% BC % E3% 83% AD% E3% 81% 8B% E3% 82% 89% 2Caps% 2C285 & sr = 8-1)]
OS: Windows 10/Ubuntu 20.04 LTS Jupyter Notebook Python Version: Python 3.8
Recommended Posts