🖖🏿 📷 ♉️ Apprentissage automatique. Réseaux de neurones (partie 1): le processus d'apprentissage Perceptron 👼🏼 ⚱️ ⛹🏼

Je tiens à noter à l'avance que ceux qui savent comment le perceptron apprend ne trouveront guère de nouveauté dans cet article. Vous pouvez l'ignorer en toute sécurité. Pourquoi j'ai décidé d'écrire ceci - Je voudrais écrire une série d'articles liés aux réseaux de neurones et à l'utilisation de TensorFlow.js, donc je ne pouvais pas omettre des extraits théoriques généraux. Par conséquent, je vous demande de traiter l'idée finale avec beaucoup de patience et de compréhension.

Dans la programmation classique, le développeur décrit dans un langage de programmation spécifique un certain ensemble de règles rigoureusement spécifié, qui a été déterminé sur la base de ses connaissances dans un domaine spécifique et qui, en première approximation, décrit les processus se produisant dans le cerveau humain lors de la résolution d'un problème similaire.

Par exemple, une stratégie pour jouer au tic-tac-toe, aux échecs, etc. peut être programmée (Figure 1).

Figure 1 - L'approche classique de la résolution de problèmes

Alors que les algorithmes d'apprentissage automatique peuvent définir un ensemble de règles pour résoudre des problèmes sans la participation du développeur, mais uniquement en fonction de la disponibilité d'un ensemble de données de formation.

Un ensemble de formation est un ensemble d'entrées associées à un ensemble de résultats attendus (réponses, extrants). A chaque étape de la formation, le modèle, en modifiant l'état interne, optimisera et réduira l'erreur entre la sortie réelle du modèle et le résultat attendu (Figure 2).

Figure 2 - Apprentissage automatique

Les réseaux de neurones

Pendant longtemps, les scientifiques, inspirés par les processus qui se déroulent dans notre cerveau, ont tenté de faire de la rétro-ingénierie du système nerveux central et d'essayer d'imiter le travail du cerveau humain. Grâce à cela, toute une direction dans l'apprentissage automatique est née: les réseaux de neurones.

Dans la figure 3, vous pouvez voir les similitudes entre la conception d'un neurone biologique et la représentation mathématique d'un neurone utilisé dans l'apprentissage automatique.

Figure 3 - Représentation mathématique d'un neurone

Dans un neurone biologique, un neurone reçoit des signaux électriques de dendrites, modulant des signaux électriques avec différentes forces, qui peuvent exciter le neurone lorsqu'une certaine valeur seuil est atteinte, ce qui à son tour conduira à la transmission d'un signal électrique à d'autres neurones via des synapses.

Perceptron

Modèle mathématique d'un réseau de neurones, constitué d'un neurone, qui effectue deux opérations séquentielles (Figure 4):

calcule la somme des signaux d'entrée en tenant compte de leurs poids (conductance ou résistance) de la connexion
${s u m = \vec{X}}^{T} \vec{W} + \vec{B} = \sum_{i = 1}^{n} x_{i} w_{i} + b$
${sum=\ \vec{X}}^T\vec{W}+\vec{B}=\sum_{i=1}^{n}{x_iw_i}+b$
applique la fonction d'activation à la somme totale des signaux d'entrée.
$o u t = φ (s u m)$
$out=\varphi(sum)$

Figure 4 - Modèle mathématique du perceptron

Toute fonction différentiable peut être utilisée comme fonction d'activation, les plus couramment utilisées sont données dans le tableau 1. Le choix de la fonction d'activation incombe à l'ingénieur, et généralement ce choix est basé soit sur l'expérience déjà existante dans la résolution de problèmes similaires, soit simplement par la méthode sélection.

La note

Cependant, il est recommandé que si la non-linéarité est nécessaire dans un réseau de neurones, la fonction ReLU est la mieux adaptée en tant que fonction d'activation, qui présente les meilleurs taux de convergence du modèle pendant le processus d'apprentissage.

Tableau 1 - Fonctions d'activation communes


Linear function	$φ (x) = x$ $\varphi\left(x\right)=x$	.
Sigmoid function	$φ (x) = \frac{1}{1 + e^{- x}}$ $\varphi\left(x\right)=\frac{1}{1+e^{-x}}$
Softmax function	$φ (x_{j}) = \frac{e^{x_{j}}}{\sum_{i} e^{x_{i}}}$ $\varphi\left(x_j\right)=\frac{e^{x_j}}{\sum_{i} e^{x_i}}$	$φ ([\begin{matrix} 1.2 \\ 0.9 \\ 0.4 \end{matrix}]) = [\begin{matrix} 0.46 \\ 0.34 \\ 0.20 \end{matrix}]$ $\varphi \left ( \begin{bmatrix} 1.2\\ 0.9\\ 0.4 \end{bmatrix} \right ) = \begin{bmatrix} 0.46\\ 0.34\\ 0.20 \end{bmatrix}$ ( 2)
Hyperbolic Tangent function	$φ (x) = \frac{e^{x} - e^{- x}}{e^{x} - e^{- x}}$ $\varphi\left(x\right)=\frac{e^x-e^{-x}}{e^x-e^{-x}}$	[-1, 1]. , ,
Rectified Linear Unit (ReLU)	$φ (x) = max (0, x)$ $\varphi\left(x\right)=\max(0,x)$	, , sigmoid tanh
Leaky ReLU	$φ (x) = max (0.01 x, x)$ $\varphi\left(x\right)=\max(0.01x,x)$	ReLU , 0

Processus d'apprentissage Perceptron

Le processus d'apprentissage se compose de plusieurs étapes. Pour plus de clarté, nous considérerons un certain problème fictif que nous allons résoudre avec un réseau de neurones constitué d'un neurone avec une fonction d'activation linéaire (il s'agit essentiellement d'un perceptron sans fonction d'activation du tout), et pour simplifier la tâche, nous exclurons le nœud de déplacement b dans le neurone (Figure 5) ...

Figure 5 - Le jeu de données d'apprentissage et l'état du réseau de neurones à l'étape de formation précédente

À ce stade, nous avons un réseau de neurones dans un certain état avec certains poids de connexion qui ont été calculés à l'étape précédente de formation du modèle, ou s'il s'agit de la première itération de la formation, alors les valeurs des poids de connexion sont sélectionnées dans ordre aléatoire.

Alors, imaginons que nous avons un ensemble de données d'entraînement, les valeurs de chaque élément de l'ensemble sont représentées par un vecteur de données d'entrée, contenant 2 paramètres (fonctionnalité)

x_{1}, x_{2}

$x_1,x_2$ ... En dessous de

x_{1}, x_{2}

$x_1,x_2$ dans le modèle, selon le domaine considéré, tout peut être implicite: le nombre de pièces de la maison, la distance entre la maison et la mer, eh bien, ou nous essayons simplement d'entraîner le réseau de neurones avec l'opération logique ET, ou OU.

Chaque vecteur d'entrée de l'ensemble d'apprentissage est mappé à un vecteur de sortie attendu. Dans ce cas, le vecteur de données de sortie ne contient qu'un seul paramètre, qui, encore une fois, en fonction du domaine choisi, peut signifier n'importe quoi - le prix d'une maison, résultat de l'exécution d'une opération logique ET ou OU.

ÉTAPE 1 - Processus d'anticipation

A cette étape, nous calculons la somme des signaux d'entrée en tenant compte du poids de chaque liaison et appliquons la fonction d'activation (dans notre cas, il n'y a pas de fonction d'activation). Faisons les calculs pour le premier élément de l'ensemble d'apprentissage:

y_{p r e d i c t e d} = \sum_{i = 1}^{n} x_{i} w_{i} = 1 \cdot 0.1 + 0.5 \cdot 0.2 = 0.2

$y_{predicted}=\sum_{i=1}^{n}{x_iw_i}=1\cdot0.1+0.5\cdot0.2=0.2$

Figure 6 - Propagation avant de l'erreur

Veuillez noter que la formule ci-dessus est une équation mathématique simplifiée pour le cas particulier des opérations tensorielles.

Un tenseur est essentiellement un conteneur de données qui peut avoir N axes et un nombre arbitraire d'éléments le long de chacun des axes. La plupart des tenseurs sont familiers avec les mathématiques - vecteurs (tenseur à un axe), matrices (tenseur à deux axes - lignes, colonnes).

La formule peut être écrite sous la forme suivante, où vous verrez les matrices familières (tenseurs) et leur multiplication, et comprendrez également quel type de simplification a été discuté ci-dessus:

{\vec{Y}}_{p r e d i c t e d} = {\vec{X}}^{T} \vec{W} = {[\begin{matrix} x_{1} \\ x_{2} \end{matrix}]}^{T} \cdot [\begin{matrix} w_{1} \\ w_{2} \end{matrix}] = [\begin{matrix} x_{1} & x_{2} \end{matrix}] \cdot [\begin{matrix} w_{1} \\ w_{2} \end{matrix}] = [x_{1} w_{1} + x_{2} w_{2}]

${\vec{Y}}_{predicted}=\ {\vec{X}}^T\vec{W}=\left[\begin{matrix}x_1\\x_2\\\end{matrix}\right]^T\cdot \left [ \begin{matrix} w_1\\ w_2 \end{matrix} \right ]=\left [ \begin{matrix} x_1 & x_2 \end{matrix} \right ] \cdot \left [ \begin{matrix} w_1\\ w_2 \end{matrix} \right ] =\left [ x_1w_1+x_2w_2 \right ]$

ÉTAPE 2 - Calculer la

fonction d' erreur La fonction d'erreur est une métrique qui reflète l'écart entre la sortie attendue et reçue. Les fonctions d'erreur suivantes sont couramment utilisées:

- Erreur quadratique moyenne (MSE) - cette fonction d'erreur est particulièrement sensible aux valeurs aberrantes de l'ensemble d'apprentissage, car elle utilise le carré de la différence entre les valeurs réelles et attendues (une valeur aberrante est une valeur éloignée des autres valeurs de ensemble de données, qui peut parfois apparaître en raison d'erreurs de données, telles que le mélange de données avec différentes unités de mesure ou de mauvaises lectures du capteur):

L = \frac{1}{N} \sum_{i = 1}^{N} {(y_{p r e d i c t e d (i)} - y_{e x p e c t e d (i)})}^{2}

$L=\frac{1}{N}\sum_{i=1}^{N}\left(y_{predicted(i)}-y_{expected(i)}\right)^2$

- écart quadratique moyen (Root MSE) - en fait, c'est la même chose que l'erreur quadratique moyenne dans le contexte des réseaux de neurones, mais cela peut refléter l'unité physique réelle de mesure, par exemple, si dans un réseau de neurones les paramètres de sortie d'un réseau de neurones sont le prix d'une maison en dollars, alors l'unité de mesure l'erreur quadratique moyenne sera le dollar carré (

$^{2}

$$^2$ ), et pour l'écart type, il s'agit du dollar ($), ce qui simplifie naturellement légèrement la tâche de l'analyse humaine:

L = \sqrt{\frac{1}{N} \sum_{i = 1}^{N} {(y_{p r e d i c t e d (i)} - y_{e x p e c t e d (i)})}^{2}}

$L=\sqrt{\frac{1}{N}\sum_{i=1}^{N}\left(y_{predicted(i)}-y_{expected(i)}\right)^2}$

- l' écart moyen (Mean Absolute Error, MAE) - contrairement aux deux valeurs ci-dessus, n'est pas si sensible aux émissions:

L = \frac{1}{N} \sum_{i = 1}^{N} | y_{p r e d i c t e d (i)} - y_{e x p e c t e d (i)} |

$L=\frac{1}{N}\sum_{i=1}^{N}\left|y_{predicted(i)}-y_{expected(i)}\right|$

- entropie croisée - utilisations pour les tâches de classification:

L = - \sum_{i = 1}^{N} \sum_{j = 1}^{M} y_{e x p e c t e d (i j)} \log (y_{p r e d i c t e d (i j)})

$L=-\sum_{i=1}^{N}\sum_{j=1}^{M}{y_{expected(ij)}\log(y_{predicted(ij)})}$

Où

N

$N$ - le nombre d'exemplaires du kit de formation

M

$M$ - le nombre de classes lors de la résolution des problèmes de classification

y_{e x p e c t e d}

$y_{expected}$ - valeur de sortie attendue

y_{p r e d i c t e d}

$y_{predicted}$ - la valeur de sortie réelle du modèle entraîné

Pour notre cas particulier, nous utiliserons MSE:

L = \frac{1}{N} \sum_{i = 1}^{N} {(y_{p r e d i c t e d (i)} - y_{e x p e c t e d (i)})}^{2} = {(0.2 - 1)}^{2} = 0.64

$L=\frac{1}{N}\sum_{i=1}^{N}\left(y_{predicted(i)}-y_{expected(i)}\right)^2={(0.2-1)}^2=0.64$

ÉTAPE 3 - Rétropropagation

L'objectif de l'entraînement du réseau neuronal est simple - il est de minimiser la fonction d'erreur:

L \to m i n

$L\rightarrow min$

Une façon de trouver le minimum d'une fonction est de modifier les poids de connexion dans le sens opposé au vecteur de gradient à chaque étape suivante de l'apprentissage - la méthode de descente de gradient, et cela ressemble mathématiquement à ceci:

{\vec{w}}^{(k + 1)} = {\vec{w}}^{k} - μ \nabla L ({\vec{w}}^{k})

${\vec{w}}^{(k+1)}={\vec{w}}^k-\mu\nabla L({\vec{w}}^k)$

Où

k

$k$ - k-ième itération de la formation des réseaux neuronaux;

μ

$\mu$ - le taux d'apprentissage est fixé par l'ingénieur, il peut généralement être de 0,1; 0.01 (sur la manière dont l'étape d'apprentissage affecte le processus de convergence d'apprentissage, notez un peu plus tard)

\nabla L

$\nabla L$ - le gradient de la fonction d'erreur

Pour trouver le gradient, on utilise des dérivées partielles par rapport aux arguments personnalisés

w_{1}, w_{2}

$w_1,w_2$ :

\nabla L (\vec{w}) = [\begin{matrix} \frac{\partial L}{\partial w_{1}} \\ ⋮ \\ \frac{\partial L}{\partial w_{N}} \end{matrix}]

$\nabla L\left(\vec{w}\right)=\left[\begin{matrix}\frac{\partial L}{\partial w_1}\\\vdots\\\frac{\partial L}{\partial w_N}\\\end{matrix}\right]$

Dans notre cas particulier, compte tenu de toutes les simplifications, la fonction d'erreur prend la forme:

L (w_{1}, w_{2}) = {(y_{p r e d i c t e d} - y_{e x p e c t e d})}^{2} = {(x_{1} w_{1} + x_{2} w_{2} - y_{e x p e c t e d})}^{2} =

$L\left(w_1,w_2\right)={(y_{predicted}-y_{expected})}^2={(x_1w_1+x_2w_2-y_{expected})}^2=$

= {(1 \cdot w_{1} + 0.5 \cdot w_{2} - 1)}^{2}

$={(1\cdot w_1+0.5\cdot w_2-1)}^2$

Mémo des formules dérivées

,

$\frac{d}{d x} c = 0; c = c o n s t$
$\frac{d}{dx}c=0;c=const$
$\frac{d}{d x} [c f (x)] = c f^{'} (x); c = c o n s t$
$\frac{d}{dx}\left[cf\left(x\right)\right]=cf^\prime\left(x\right);\ c=const$
$\frac{d}{d x} x^{n} = n x^{n - 1}$
$\frac{d}{dx}x^n=nx^{n-1}$

$\frac{d}{d x} [f (x) \pm g (x)] = f^{'} (x) \pm g^{'} (x)$
$\frac{d}{dx}\left[f\left(x\right)\pm g(x)\right]=f^\prime\left(x\right)\pm g^\prime(x)$
$\frac{d}{d x} [f (x) g (x)] = f^{'} (x) g (x) + g^{'} (x) f (x)$
$\frac{d}{dx}\left[f\left(x\right)g\left(x\right)\right]=f^\prime\left(x\right)g\left(x\right)+g^\prime\left(x\right)f\left(x\right)$
$\frac{d}{d x} f (g (x)) = f^{'} (g (x)) g^{'} (x)$
$\frac{d}{dx}f\left(g\left(x\right)\right)=f^\prime(g(x))g^\prime(x)$

Trouvons les dérivées partielles suivantes:

\frac{\partial}{\partial w_{1}} {(w_{1} + 0.5 w_{2} - 1)}^{2} = 2 \cdot (w_{1} + 0.5 w_{2} - 1) \frac{\partial}{\partial w_{1}} (w_{1} + 0.5 w_{2} - 1) =

$\frac{\partial}{\partial w_1}{(w_1+0.5w_2-1)}^2=2\cdot\left(w_1+0.5w_2-1\right)\frac{\partial}{\partial w_1}\left(w_1+0.5w_2-1\right)=$

= 2 \cdot (w_{1} + 0.5 w_{2} - 1) \cdot 1 = 2 (0.1 + 0.5 \cdot 0.2 - 1) = - 1.6

$=2\cdot\left(w_1+0.5w_2-1\right)\cdot1=2\left(0.1+0.5\cdot0.2-1\right)=-1.6$

\frac{\partial}{\partial w_{2}} {(w_{1} + 0.5 w_{2} - 1)}^{2} = 2 \cdot (w_{1} + 0.5 w_{2} - 1) \frac{\partial}{\partial w_{2}} (w_{1} + 0.5 w_{2} - 1) =

$\frac{\partial}{\partial w_2}{(w_1+0.5w_2-1)}^2=2\cdot\left(w_1+0.5w_2-1\right)\frac{\partial}{\partial w_2}\left(w_1+0.5w_2-1\right)=$

= 2 \cdot (w_{1} + 0.5 w_{2} - 1) \cdot 0.5 = 2 (0.1 + 0.5 \cdot 0.2 - 1) \cdot 0.5 = - 0.8

$=2\cdot\left(w_1+0.5w_2-1\right)\cdot0.5=2\left(0.1+0.5\cdot0.2-1\right)\cdot0.5=-0.8$

Ensuite, le processus de rétro-propagation de l'erreur est le mouvement le long du modèle de la sortie vers l'entrée avec modification des poids du modèle dans la direction opposée au vecteur gradient. Réglage de l'étape d'apprentissage 0,1 (taux d'apprentissage) que nous avons (Figure 7):

w_{1}^{(k + 1)} = w_{1}^{(k)} - μ \frac{\partial L (w_{1}, w_{2})}{\partial w_{1}} = 0.1 - 0.1 \cdot (- 1.6) = 0.26

$w_1^{(k+1)}=w_1^{(k)}-\mu\frac{\partial L\left(w_1,w_2\right)}{\partial w_1}=0.1-0.1\cdot\left(-1.6\right)=0.26$

w_{2}^{(k + 1)} = w_{2}^{(k)} - μ \frac{\partial L (w_{1}, w_{2})}{\partial w_{2}} = 0.2 - 0.1 \cdot (- 0.8) = 0.28

$w_2^{(k+1)}=w_2^{(k)}-\mu\frac{\partial L\left(w_1,w_2\right)}{\partial w_2}=0.2-0.1\cdot\left(-0.8\right)=0.28$

Figure 7 - Rétropropagation de l'erreur

Ainsi, nous avons effectué k + 1 étapes d'apprentissage pour nous assurer que l'erreur a diminué et que la sortie du modèle avec de nouveaux poids est devenue plus proche de l'attente, nous allons effectuer le processus de propagation avant de l'erreur sur le modèle avec de nouveaux poids (voir ÉTAPE 1) :

y_{p r e d i c t e d} = x_{1} w_{1} + x_{2} w_{2} = 1 \cdot 0.26 + 0.5 \cdot 0.28 = 0.4

$y_{predicted}=x_1w_1+x_2w_2=1\cdot0.26+0.5\cdot0.28=0.4$

Comme vous pouvez le voir, la valeur de sortie a augmenté de 0,2 unité dans la bonne direction vers le résultat attendu - un (1). L'erreur sera alors:

L = {(0.4 - 1)}^{2} = 0.36

$L={(0.4-1)}^2=0.36$

Comme vous pouvez le voir, à l'étape d'entraînement précédente, l'erreur était de 0,64 et, avec les nouveaux poids - 0,36, nous avons donc ajusté le modèle dans la bonne direction.

Partie suivante de l'article:

Machine Learning. Réseaux de neurones (partie 2): modélisation OU; XOR avec TensorFlow.js

Machine Learning. Réseaux de neurones (partie 3) - Réseau convolutif sous le microscope. Explorer l'API Tensorflow.js

Apprentissage automatique. Réseaux de neurones (partie 1): le processus d'apprentissage Perceptron

Les réseaux de neurones

Perceptron

La note

Processus d'apprentissage Perceptron

More articles: