L'algorithme de descente de gradient est une méthode d'optimisation itérative pour trouver les minima d'une fonction différentiable. Dans le cas d'un seul paramètre `a` le gradient selon `a`, noté `"grad"` ou `nabla` correspond exactement à la dérivée selon `a` :
`"grad" = nabla = d/(da)`
Etant donné une fonction de coût `J(a)`, c'est une valeur que l'on veut minimiser en faisant évoluer `a`. On précise formellement les notations afin de lever les ambiguités. On déclare que `J` dépend de `a` en notant le neurone `J"←"a`. Après cette déclaration, `J` est une fonction qui s'applique par défaut à l'argument `a` (qui constitue un système de coordonnée par défaut pour la fonction `J`), faisant que si l'on rencontre l'expression `J` dans une équation où l'on attend une valeur réel alors celle-ci est égale à `J(a)`. En résumer `J"="J(a)`.
le gradient de `J` selon `a`, noté `"grad"(J)` ou `"∇"J` ou `(dJ)/(da)` ou `J'`, est utilisé pour mettre à jour le paramètre `a` en le déplaçant dans le sens qui réduit `J`. La mise à jour du paramètre est définie comme suit :
`J←a`
`a := a - eta J'`
Ce qui correspond à une variation du paramètre `a` noté `deltaa = "-" eta J'`. Remarquez que si on choisit une variation `deltaa` telle que multipliée par la pente de `J` elle comble complètement `J` c'est à dire telle que `deltaa J' = "-"J` et donc où `deltaa = "-"J"/"J'`, on obtient alors la méthode de Newton, et l'itération devient alors :
`a := a -J/(J')`
Cette méthode cherche les racines `{a "/" J(a)"="0}` et ne convient pas pour chercher les minima de `J`. C'est pourquoi on l'utilise non pas sur `J` mais sur la dérivée `J'`, car les racines de `J'` correspondent aux minima et maxima de `J`. L'itération devient alors :
`a := a -(J')/(J'')`
Dans le cas générale il y a `n` paramètres `vec a=(a_1,a_2,...,a_n)`. L'algorithme est vectorialisé. Le gradient selon `vec a`, noté `vec"grad"` ou `vec nabla` correspond à l'opération de dérivation suivante :
`vec "grad" = vec nabla = ((del/(dela_1)),(del/(dela_2)),(...),(del/(dela_n)))`
Etant donné une fonction de coût `J(a_1,a_2,...,a_n)` que l'on note `J(vec a)`, le gradient de `J` selon `vec a`, noté `vec"grad"(J)` ou `vec∇J` ou `vec((dJ)/(d vec a))` ou `vec(J')`, est utilisé pour mettre à jour le paramètre vectoriel `vec a` en le déplaçant dans la direction qui réduit `J`. La mise à jour du paramètre est définie comme suit :
`J←vec a`
`vec a := vec a - eta vec nabla J`
`((a_1),(a_2),(...),(a_n)) := ((a_1),(a_2),(...),(a_n)) - eta( ((dJ)/(da_1)), ((dJ)/(da_2)),(...),((dJ)/(da_n)) )`
Ce qui s'écrit :
`AAi, a_i := a_i-eta (delJ)/(del a_i)`
On considère un exemple comprenant 3 variables `x_1, x_2, x_3` et une variable cible `y`. On note les vecteurs comprenant toutes les observations `vec x_1, vec x_2, vec x_3, vec y` :
`vec x_1 = ((x_(1,1)),(x_(2,1)),(...),(x_(N,1))), vec x_2 = ((x_(1,2)),(x_(2,2)),(...),(x_(N,2))), vec x_3 = ((x_(1,3)),(x_(2,3)),(...),(x_(N,3))), vec y = ((y_1),(y_2),(...),(y_N))`