Note récapitulative sur l'apprentissage profond -4.3 Méthode de gradient

Résumé de l'explication

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.

4.3 Méthode du gradient

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.

Méthode de gradient

Tout d'abord, je décrirai brièvement le déroulement de ce qui est fait par la méthode du gradient.

  1. Spécifiez le point initial * x *
  2. Trouvez la pente de la fonction au point
  3. Point de mise à jour * x * basé sur l'inclinaison
  4. Répétez 2-3 jusqu'à ce que * x * soit trouvé avec une pente de 0.

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.


Formule

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.


Exemple de méthode de gradient

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.


Raisons de fixer le taux d'apprentissage à une valeur appropriée

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.

Résumé

  • La méthode du gradient est une méthode de mise à jour des variables afin de maximiser ou de minimiser la valeur de la fonction. --Il existe deux types de méthodes de gradient: la méthode Gradient Decent et la méthode Gradient Ascent. --Il est nécessaire de spécifier une valeur appropriée pour le taux d'apprentissage.

Livre de référence

[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)]

Environnement d'exécution

OS: Windows 10/Ubuntu 20.04 LTS Jupyter Notebook Python Version: Python 3.8

Recommended Posts