IREN - suite

Index du cours

Rétropropagation du gradient

Fonction logistique

Calculons l’influence du poids

$w_{2,2}^2$ sur l'erreur quadratique

$E:\frac{\delta E}{\delta w_{2,2}^2}$

La derivee partielle de

$y$ par rapport a

$z$ est

$y(1-y)$

On note t (truth) la vraie valeur avec l'erreur quadratique

Correction

Que vaut le gradient de

$E:\mathrm{\nabla }E$?

Qu'est-ce qu'on modifie pour arriver au bon resultat ?
Les poids, on a 18 poids donc

$\mathrm{\nabla }E$ est a dimension 18.

$$\mathrm{\forall }\text{ layer }l,W^l\leftarrow W^l-\eta \mathrm{\nabla }E(W^l)$$

Pourquoi ce titre ?

On fait une propagation a l'envers, "retropropagation" pour remonter l'erreur

La methode du gradient

Le but est de trouver le vecteur

$w$ qui minimise notre erreur

$E$

Avec un

$w_0$ choisi, l'algorithme de descente du gradient est:

$$w_{t+1}=w_t-\eta \mathrm{\nabla }E(W_t)$$

jusuq'a atteindre un seuil choisi

Representation graphique

Cas simple: l'erreur est une fonction convexe.

Si on modifie les cas apres chaque donnees, on risque d'osciller

travailler par paquet de données.

$\to$ Notion de batch

Lorsque l’elliptiques est allongée, son gradient est quasiment orthogonal à son axe long ce qui n’est pas du tout la bonne direction vers le minimum.

la convergence sera longue

Travail sur les donnees

Jouer sur l'echelle

$$\begin{gathered} y=w_0{i}_0+w_1{i}_1 \\ E=(y-t{)}^2 \end{gathered}$$

Soit comme jeux de donnees:

$$\begin{array}{rlr}& \begin{array}{cccc}0,1& 10& \to & 2\\ 0,1& -10& \to & 2\end{array}& \begin{array}{cccc}1& 1& \to & 2\\ 1& -1& \to & 2\end{array}\end{array}$$

La fonction d’erreur correspondante a la forme suivante:

normaliser les données pour éviter des fonctions d’erreur écrasées

Translation

$$\begin{gathered} y=w_0{i}_0+w_1{i}_1 \\ E=(y-t{)}^2 \end{gathered}$$

Soit comme jeux de donnees:

$$\begin{array}{rlr}& \begin{array}{cccc}101& 101& \to & 2\\ 101& 99& \to & 0\end{array}& \begin{array}{cccc}1& 1& \to & 2\\ 1& -1& \to & 0\end{array}\end{array}$$

L’erreur correspondante aux jeux de données a la forme suivante:

centrer les données pour éviter des fonctions d’erreur écrasées.

Les minimums locaux

Une fonction d'erreur n'est pas forcement elliptique, il faut s'attendre a avoir des minimums locaux.

Le point de convergence dépend du point de départ d’où le risque de finir
dans un minimum local.

Si on lance une bille, en fonction de la ou elle se trouve elle fini dans un minimum local

Comment sortir d’un minimum local pour rejoindre un minimum global ?

Les solveurs

Pour contrer ces differents problemes, on a differents solveurs

Moment et Nesterov

On donne une inertie

$\alpha$ a la methode:

On ne calcule pas le gradient au poids des poids, mais aux poids modifies.
Nesterov propose de travailler sur les données mise à jour:

Ca peut aider a "sortir" des trous et reduire les oscillations

Si notre bille s'approche d'un trou, on lui dira "Non va pas par la, fait demi-tour"

RMSprop

Le coef d'apprentissage

$\eta$ influence beaucoup la convergence.

On peux choisir autant de

${\eta }_i$ que de parametres existants:

${\eta }_i=\epsilon {\mu }_i\frac{\delta E}{\delta {\omega }_i}$

Avec:

Ca marche mal avec les "mini-batches"

• $9\frac{\delta E}{\delta {\omega }_i}$ de
  $0,1$ suivi d'une de
  $-0,9$ devrait faire du surplace, mais pas avec cette methode

On prefere moyenner les gradients dans le temps, l'algorithme est:

Adagrad

On cherche le w aui minimise

$E$, donc

$\mathrm{\nabla }E(w)=0$

Au pas de temps

$t$, on est au point

$w_t$, on cherche

$\delta w$ tel que

$\mathrm{\nabla }E(w-t+\delta w)=0$ donc avec un developpement limite:

Avec

${\mathrm{\nabla }}^{2}E$ la matrice hessienne de

$E$.
L'algorithme iteratif est:

Calculer l'inverse de la matrice essienne est trop couteux, on va chercher quelque chose qui lui ressemble,

$V_t$ pour Adagrad:

Exemple de convergence

Regardons à quelle vitesse convergent différentes méthodes suivant la forme
de la fonction d’erreur.

An overview of gradient descent optimization algorithms

Trois types de reseaux neuronaux

Quelques exemples de reseaux neuronaux:

• reseau simple pour separer des donnees
  • Qui a le cancer, qui ne l'a pas
• reseau recursif pour faire des additions
• reseau de convolution pour comprendre une image

Une idée pour séparer les données sur deux cercles?

Separation

Relu defini un demi-plan, on va utiliser 6 Relu

$(\nearrow )$ pour faire un cercle grossier et une sigmoide

$(⇝)$ pour separer les 2 cercles

Recursif

On veut calculer

$0101011+1001110$, on fait comme un addition a la main

On a besoin d'avoir des retenues (si on a

$1+1$ par exemple), c'est un reseau a memoire.

Les cellules grises sont la memoire, cad les retenues, des operations precedentes.

Ces reseau sont compliques a faire converger, il faut que la memoire fonctionne correctement.

Convolution

Les Convolution Neural network sont la grande reussite du deep learning.

Le but est de travailler sur des images pour en extraire ses caracteristiques

En entrée nous avons une image

$N\times N\times 3$ (en RGB) dont nous diminuonsla surface à chaque couche du réseau pour augmenter sa profondeur.

À la fin on peut voir l’image comme un vecteur de caractéristiques.

Ensuite (pas sur le dessin) on peut utiliser un réseau neuronal classique pour classer l’image.

Les convolutions

Un filtre est un masque d'une certaine taille dont on a donné une valeur pour chacune des couches

On fait la somme de tous les poids

$\times$ toutes les valeurs et on travaille un pixel sur 2.

La taille des filtres est le nombre de canaux de l'image de depart.

Chacun des 5 filtres aura combien de canal ?
2 car l'image d'arrivee a 2 canaux

Diminuer la surface

L'exemple précédent saute un pas (travailler un pixel sur 2), qui réduit la surface. Si on a pas de saut de plus de filtre

$\to$ le nombre de données EXPLOSE.

pooling: On réduit la surface de l'image au fur et a mesure qu'on augmente sa profondeur.

Le choix du maximum est le plus utilisé. On pourrait faire une moyenne mais cela risque de réduire le contraste de l’image.

Le Net 5

Le premier CNN, qui a bien fonctionné, pour lire les codes postaux sur les enveloppes, développé en 90 par Yann Le Cun

Evolution des CNN

Les reseaux augmentent en précision, taille et nombre d'opérations.

De plus en plus compliqué:

On rajoute des trucs pour améliorer les résultats (ou converger).

L'idée est de reprendre des données antérieures pour ne pas trop oublier. Le saut correspond à l’opération:

$$y=F(x,w)+x$$

Kaggle

Le Kaggle d'Olivier Ricou