Contents

Réseaux de neurones

Une méthode avec une longue histoire:

  • 1943: Warren McCulloch, Walter Pitts: comment fonctionnent les neurones

Vagues: modes et oubli….

Comment faire “apprendre” une machine?

L’idée de l’interconnexion: chaque “neurone” est un élément qui “vote” pour quelque chose. On essaie de trouver les meilleures conditions pour que l’ensemble de ces votes donne le résultat attendu. De cette manière on aura une structure qui permet ensuite de donner un output à partir d’un input.

Cas typiques: la reconnaissance des chiffres manuscrites.

Exemple du panier

C’est un problème philosophique intéressant qui peut être relié à la vieille question des universaux.

Pour une explication mathématique plus approfondie cf. ici - c’est de ce texte que j’ai pris les images.

Les étapes:

  1. On prend une liste de inputs - un ensemble de noeuds avec des valeurs

  2. On mets des poids aléatoires

  3. On calcule les valeurs des noeuds de la couche cachée

  4. On calcule la valeur de l’output

  5. On regarde l’erreur par rapport à la valeur attendue pour l’output

  6. On corrige les poids

Cela donne un modèle qui permet de calculer des outputs à partir de valeurs en entrée pour lesquelles on ne connait pas le résultats attendu.

C’est comme si, faisant ainsi, on déterminait des “caractéristiques” de chaque input qui sont représentée par les couches cachées.

Caractéristiques

On a une couche avec des entrants (input layer), des couches intermédiaires “cachées” (hidden layers) et une couche de sortie (output layer).

L’idée est de faire en sorte que les neurones de chaque couche “votent” pour les neurones de la couche suivante jusqu’à arriver à un résultat final, qui sera le résultat de sortie.

Pour ce faire, chaque neurone aura un chiffre d’activation et des poids - différentes pour chaque neurone de la couche suivante.

Calculer l’activation de chaque neurone dans la couche suivante

Si nous avons n neurones dans la première couche, leurs activations peuvent être représentées avec un vecteur:

\[\begin{split} \begin{bmatrix} a_0^{0}\\ a_1^{0}\\ \vdots \\ a_n^{0}\\ \end{bmatrix} \end{split}\]

Et leurs poids avec une matrice (car chaque neurone a un poids différent pour chaque neurone de la couche suivante et donc chaque ligne de la matrice représente l’ensemble des poids d’un neurone de la première couche sur tous les neurones, k, de la couche suivante).

\[\begin{split} \begin{bmatrix} w_{0,0} & w_{0,1} & \cdots & w_{0,k}\\ w_{1,0} & w_{1,1} & \cdots & w_{1,k}\\ \vdots & \vdots & \ddots & \vdots \\ w_{n,0} & w_{n,1} & \cdots & w_{n,k}\\ \end{bmatrix} \end{split}\]

Dans ce cas:

\[ 1.1 \times 0.3+2.6 \times 1.0 = 2.93 \]

Rétropropagation

Rétropropagation

Une fois qu’on a fait toutes les multiplications en utilisant des poids aléatoires, on peut regarder le résultat sur la dernière couche de neurones et regarder comment il diffère du résultat attendu.

À partir de cette différence on pourra revenir à l’arrière et ajuster les poids pour avoir un résultat plus proche de celui qu’on attendait. C’est ce qu’on fait avec la rétropropagation du gradient.

Un exemple d’application

Admettons de vouloir entrainer un réseau de neurones à reconnaître des chiffres manuscrites.

Nous allons avoir comme entrées une série d’images et comme sorties les chiffres de 0 à 9.

Évidemment chaque image sera associée à un chiffre.

Ce corpus est ce qui nous sert pour entrainer le réseau de neurones.

Maintenant nous allons donner à notre réseau de neurones une image à la fois.

Par exemple nous pouvons imaginer que chaque pixel de l’image est un neurone d’input. Une image à 400 pixels aura donc 400 neurones. Admettons de travailler en noir et blanc: nous pouvons donner à chacun de ces neurones une valeur d’activation entre 0 (complètement blanc) et 1 (complètement noir).

Nous aurons ensuite une couche cachée avec un nombre plus réduit de neurones et des poids aléatoires. Et finalement un output qui devra avoir une valeur entre 0 et 9: c’est le chiffre associé à l’image.

Admettons que l’image que nous avons donné comme input soit un 3. Le réseau de neurones aura probablement donné un output différent (vu que les poids sont aléatoires).

Nous allons donc corriger les poids pour essayer d’avoir le résultat attendu.

Nous allons répéter cela sur l’ensemble du corpus. Nous aurons 10 modèles capable chacun de “reconnaître” un chiffre. Nous allons ensuite les mettre ensemble pour avoir 10 neurones de sortie. Cela nous donnera à la fin un algorithme capable de nous donner pour une image les probabilités qu’elle soit un des 10 chiffres.

Par exemple, en donnant à l’algorithme une image x l’algorithme donnera comme output quelque chose comme:

[ (0,0.2),
  (1, 0.1),
  (2, 0.3),
  (3, 0.1),
  (4, 0.0),
  (5, 0.4),
  (6, 0.1),
  (7, 0.9),
  (8, 0.2),
  (9, 0.3)
]

En nous indiquant ainsi que l’image est probablement un 7.

L’algorithme aura donc “appris” des caractéristique des images qui lui permettent de les associer au bon chiffre.

Ce qui pose problème est que ces “caractéristiques” (qui sont les activations et les poids des couches intermédiaires) ne semblent pas correspondre à quelque chose qu’un être humain serait capable de comprendre…

Word embeddings Entraîner un modèle…