diff --git a/docs/fr/index.md b/docs/fr/index.md index 53a685078..045eb818d 100644 --- a/docs/fr/index.md +++ b/docs/fr/index.md @@ -12,10 +12,10 @@ translator: Loïck Bourdois **DS-GA 1008 - PRINTEMPS 2020 - [NYU CENTER FOR DATA SCIENCE](http://cds.nyu.edu/)** | INSTRUCTEURS | Yann Le Cun & Alfredo Canziani | -| CONFÉRENCES | Lundi 16h55 - 18h35, [GCASL C95](http://library.nyu.edu/services/campus-media/classrooms/gcasl-c95/) | -| PRATIQUE | Mardi 19h10 - 20h00, [GCASL C95](http://library.nyu.edu/services/campus-media/classrooms/gcasl-c95/) | +| COURS MAGISTRAUX | Lundi 16h55 - 18h35, [GCASL C95](http://library.nyu.edu/services/campus-media/classrooms/gcasl-c95/) | +| TRAVAUX DIRIGÉS | Mardi 19h10 - 20h00, [GCASL C95](http://library.nyu.edu/services/campus-media/classrooms/gcasl-c95/) | | FORUM | [r/NYU_DeepLearning](https://www.reddit.com/r/NYU_DeepLearning/) | -| MATERIEL | [Google Drive](https://bitly.com/DLSP20), [Notebooks](https://github.com/Atcold/pytorch-Deep-Learning) | +| MATÉRIEL | [Google Drive](https://bitly.com/DLSP20), [Notebooks en anglais](https://github.com/Atcold/pytorch-Deep-Learning) | [Notebooks en français](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French) | - Conférence + Cours magistral Histoire et motivations 🖥️ @@ -62,8 +62,8 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Evolution et Apprentissage profond - Pratique - Réseaux de neurones (Neural Network : NN) + Travaux dirigés + Réseaux de neurones 📓 📓 @@ -73,8 +73,8 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence - Descente de gradient stochastique et rétropropagation + Cours magistral + Descente de gradient stochastique et rétropropagation 🖥️ 🎥 @@ -82,8 +82,8 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ La rétropropagation en pratique - Pratique - Entraînement d’un NN + Travaux dirigés + Entraînement d’un réseau de neurones 🖥 📓 @@ -94,7 +94,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Transformation de paramètres 🖥️ @@ -103,7 +103,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Réseaux de neurones convolutifs (ConvNets) - Pratique + Travaux dirigés Propriétés des signaux naturels 🖥 @@ -114,7 +114,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Pratique + Travaux dirigés Convolution à 1 dimension 📓 @@ -124,7 +124,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Optimisation I 🖥️ @@ -133,7 +133,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Optimisation II - Pratique + Travaux dirigés ConvNets, autograd 📓 @@ -144,7 +144,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Applications des ConvNets 🖥️ @@ -154,7 +154,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Réseaux de neurones récurrents (RNNs) et Attention - Pratique + Travaux dirigés Entraîner des RNNs 🖥️ @@ -166,16 +166,16 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence - Modèles à base d’énergie (EBM) + Cours magistral + Modèles à base d’énergie (EBMs) 🖥️ 🎥 - Apprentissage auto-supervisé et EBM + Apprentissage autosupervisé et EBMs - Pratique + Travaux dirigés Auto-encodeurs 🖥️ @@ -186,16 +186,16 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Méthodes contrastives 🖥️ 🎥 - Variable latente régularisée + Variable latente régularisée - Pratique + Travaux dirigés Entraîner des Auto-Encodeurs Variationnels (VAEs) 🖥️ @@ -206,7 +206,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Eparsité 🖥️ @@ -215,7 +215,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Modèles du monde, Réseaux génératifs antagonistes (GANs) - Pratique + Travaux dirigés Entraîner des GANs 🖥️ @@ -226,16 +226,16 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence - Apprentissage auto-supervisé appliqué à la vision par ordinateur I + Cours magistral + Apprentissage autosupervisé appliqué à la vision par ordinateur I 🖥️ 🎥 - Apprentissage auto-supervisé appliqué à la vision par ordinateur II + Apprentissage autosupervisé appliqué à la vision par ordinateur II - Pratique + Travaux dirigés Contrôle prédictif 🖥️ @@ -246,7 +246,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Fonctions d’activation 🖥️ @@ -257,7 +257,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Fonctions de perte - Pratique + Travaux dirigés PPUU 🖥️ @@ -268,7 +268,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence + Cours magistral Apprentissage profond pour le traitement du langage naturel (NLP) I 🖥️ @@ -277,7 +277,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Apprentissage profond pour le traitement du langage naturel (NLP) II - Pratique + Travaux dirigés Attention & Transformer 🖥️ @@ -288,17 +288,17 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence - Réseau convolutif sur graphe I + Cours magistral + Réseau convolutif pour graphe I 🖥️ 🎥 - Réseau convolutif sur graphe II + Réseau convolutif pour graphe II - Practicum - Réseau convolutif sur graphe III + Travaux dirigés + Réseau convolutif pour graphe III 🖥️ 📓 @@ -308,8 +308,8 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ - Conférence - Prévision structurée + Cours magistral + Prédiction de structure 🖥️ 🎥 @@ -317,7 +317,7 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ Méthodes graphiques - Practicum + Travaux dirigés Régularisation et réseaux bayésiens 🖥️ @@ -327,6 +327,23 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ 🎥 + + + + Travaux dirigés + Inférence pour les EBMs à variable latente + + 🖥️ + 🎥 + + + + Entraînement des EBMs à variable latente + + 🖥️ + 🎥 + + @@ -334,11 +351,11 @@ D’après Yann Le Cun, ces cours sont destinés à des personnes de niveau bac+ | Rôle | Photo | Contact | A propos | |:-----|:-----:|:--------|:------| -|Instructeur||Yann Le Cun
yann@cs.nyu.edu|Silver Professor en Computer
Science à la New York
University (NYU)
et lauréat du prix Turing 2019| -|Instructeur||Alfredo Canziani
canziani@nyu.edu| Prof. Ast. en Computer Science à la NYU| -|Assistant||Mark Goldstein
goldstein@nyu.edu|Doctorant en Computer Science à NYU| -|Webmaster||Zeming Lin
zl2799@nyu.edu| Doctorant en Computer Science à NYU| -|Traducteur|| Loïck Bourdois
| N'appartient pas au corps enseignant de la NYU | +|Instructeur||
Yann Le Cun
yann@cs.nyu.edu|*Silver Professor* en *Computer*
*Science* à la *New York*
*University* (NYU) et
lauréat du prix Turing 2019| +|Instructeur||Alfredo Canziani
canziani@nyu.edu| Prof. Ast. en
*Computer Science* à la NYU| +|Assistant||Mark Goldstein
goldstein@nyu.edu|Doctorant en
*Computer Science* à la NYU| +|Webmaster||Zeming Lin
zl2799@nyu.edu|Doctorant en
*Computer Science* à la NYU| +|Traducteur|| Loïck Bourdois
| N'appartient pas au corps
enseignant de la NYU | Notez qu'au lieu d'entrées scalaires, il s'agit d'entrées vectorielles. Plus généralement, il s'agit d'entrées multidimensionnelles. La rétropropagation permet de calculer la dérivée de la différence entre la sortie souhaitée et la sortie obtenue (qui est la valeur de la fonction objectif) par rapport à toute valeur à l'intérieur du réseau. Enfin, la rétropropagation est essentielle car elle s'applique à plusieurs couches. -Il est important de réfléchir à la manière d'interpréter les entrées. Par exemple, une image de $256$\times$256$ nécessite une matrice d'une valeur de 200 000. On aurait alors d'énormes matrices que les couches du réseau neuronal auraient à manipuler. Il n'est donc pas pratique d'utiliser de telles matrices. Par conséquent, il est important de faire des hypothèses sur la structure de la matrice. +Il est important de réfléchir à la manière d'interpréter les entrées. Par exemple, une image de 256$$\times$$256 nécessite une matrice d'une valeur de 200 000. On aurait alors d'énormes matrices que les couches du réseau neuronal auraient à manipuler. Il n'est donc pas pratique d'utiliser de telles matrices. Par conséquent, il est important de faire des hypothèses sur la structure de la matrice. -## [Projections aléatoires - Jupyter Notebook](https://www.youtube.com/watch?v=5_qrxVq1kvc&t=1693s) +## [Projections aléatoires - Notebook Jupyter](https://www.youtube.com/watch?v=5_qrxVq1kvc&t=1693s) -Le Notebook Jupyter peut être consulté [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/02-space_stretching.ipynb). Pour le faire fonctionner, assurez-vous que l'environnement `pDL` est installé comme indiqué dans [`README.md`](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/docs/fr/README-FR.md). +La version anglaise du *notebook* Jupyter peut être consultée [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/02-space_stretching.ipynb). Celle en français est disponible [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/02-space_stretching.ipynb). Pour le faire fonctionner, assurez-vous que l'environnement `pDL` est installé comme indiqué dans le fichier [`README.md`](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/docs/fr/README-FR.md). -### Astuce Notebook Jupyter +### Astuce notebook Jupyter -Pour voir la documentation d'une fonction dans une cellule du notebook, utilisez `Shift + Tab`. +Pour voir la documentation d'une fonction dans une cellule du *notebook*, utilisez `Shift + Tab`. ### Réseau neuronal aléatoire -Enfin, nous visualisons la transformation effectuée par un simple réseau de neurones non entraîné. Le réseau est constitué d'une couche linéaire, qui effectue une transformation affine, suivie d'une tangente hyperbolique non-linéaire, et enfin d'une autre couche linéaire. En examinant la transformation de la figure 6, nous constatons qu'elle est différente des transformations linéaires et non linéaires vues précédemment. Nous allons voir comment rendre ces transformations effectuées par les réseaux de neurones utiles pour notre objectif final de classification. +Enfin, nous visualisons la transformation effectuée par un simple réseau de neurones non entraîné. Le réseau est constitué d'une couche linéaire, qui effectue une transformation affine, suivie d'une tangente hyperbolique non-linéaire, et enfin d'une autre couche linéaire. En examinant la transformation de la figure 6, nous constatons qu'elle est différente des transformations linéaires et non linéaires vues précédemment. Nous allons voir comment rendre utiles ces transformations effectuées par les réseaux de neurones pour notre objectif final de classification.

Figure 6 : Transformation d'un réseau de neurones non entraîné diff --git a/docs/fr/week02/02-1.md b/docs/fr/week02/02-1.md index c5c0454e1..c550346b2 100644 --- a/docs/fr/week02/02-1.md +++ b/docs/fr/week02/02-1.md @@ -58,17 +58,17 @@ Les modèles paramétrés sont simplement des fonctions qui dépendent d'entrée Le modèle paramétré (fonction) prend une entrée, possède un vecteur de paramètres et produit une sortie. Dans l'apprentissage supervisé, cette sortie va dans la fonction de coût ($C(y,\bar{y}$)), qui compare la sortie réelle (${y}$) avec la sortie du modèle ($\bar{y}$). Le graphe de calcul pour ce modèle est présenté à la figure 1. |
Figure1
| -|
Figure 1 : Représentation graphique pour un modèle paramétré
| +|
Figure 1 : Représentation sous forme de graphe pour un modèle paramétré
| Exemples de fonctions paramétrées : -- Modèle linéaire - Somme pondérée des composantes du vecteur d'entrée : +- Modèle linéaire: la somme pondérée des composantes du vecteur d'entrée : $$ \bar{y} = \sum_i w_i x_i, C(y,\bar{y}) = \Vert y - \bar{y}\Vert^2 $$ -- Voisin le plus proche - Il y a une entrée $\vect{x}$ et une matrice de poids $\matr{W}$ avec chaque ligne de la matrice indexée par $k$. La sortie est la valeur de $k$ qui correspond à la ligne de $\matr{W}$ la plus proche de $\vect{x}$ : +- Voisin le plus proche : il y a une entrée $\vect{x}$ et une matrice de poids $\matr{W}$ avec chaque ligne de la matrice indexée par $k$. La sortie est la valeur de $k$ qui correspond à la ligne de $\matr{W}$ la plus proche de $\vect{x}$ : $$ \bar{y} = \underset{k}{\arg\min} \Vert x - w_{k,.} \Vert^2 $$ @@ -120,7 +120,7 @@ Les modèles paramétrés peuvent également comporter des fonctions compliquée scalar-valued - Utilisée pour représenter les fonctions de coût - - A un rendement scalaire implicite + - A une sortie scalaire implicite - Prend plusieurs entrées et produit une seule valeur (généralement la distance entre les entrées) @@ -156,28 +156,22 @@ In the standard Supervised Learning paradigm, the loss (per sample) is simply th Une fonction de perte est une fonction qui est minimisée pendant l’entraînement. Il existe deux types de pertes : -1) Perte par échantillon - +1) Perte par échantillon : $$ L(x,y,w) = C(y, G(x,w)) $$ -2) Perte moyenne - +2) Perte moyenne : -Pour toute série d'échantillons - -$$S = \lbrace(x[p],y[p]) \mid p \in \lbrace 0, \cdots, P-1 \rbrace \rbrace$$ - -La perte moyenne sur l'ensemble des $S$ est donnée par : +Pour toute série d'échantillons $S = \lbrace(x[p],y[p]) \mid p \in \lbrace 0, \cdots, P-1 \rbrace \rbrace$, la perte moyenne sur l'ensemble des $S$ est donnée par : $$L(S,w) = \frac{1}{P} \sum_{(x,y)} L(x,y,w)$$ |
Average_Loss
| -|
Figure 2 : Graphique de calcul pour le modèle avec perte moyenne
| - -Dans le paradigme standard de l'apprentissage supervisé, la perte (par échantillon) est simplement le résultat de la fonction de coût. L'apprentissage machine consiste principalement à optimiser les fonctions (généralement en les minimisant). Il peut également s'agir de trouver des équilibres de Nash entre deux fonctions, comme dans le cas des GANs (Generative adversarial network). Cela se fait en utilisant des méthodes basées sur le gradient, mais pas nécessairement sur la descente du gradient. - +|
Figure 2 : Graphe pour le modèle avec perte moyenne
| +Dans le paradigme standard de l'apprentissage supervisé, la perte (par échantillon) est simplement le résultat de la fonction de coût. L'apprentissage machine consiste principalement à optimiser les fonctions (généralement en les minimisant). Il peut également s'agir de trouver des équilibres de Nash entre deux fonctions, comme dans le cas des GANs (*Generative adversarial networks*). Cela se fait en utilisant des méthodes basées sur le gradient, mais pas nécessairement sur la descente du gradient. -## [Avantages du SGD et de la rétropropagation pour les réseaux de neurones traditionnels](https://www.youtube.com/watch?v=d9vdh3b787Y&t=1036s) +## [Avantages de la SGD et de la rétropropagation pour les réseaux de neurones traditionnels](https://www.youtube.com/watch?v=d9vdh3b787Y&t=1036s) -### Utiliser ReLU comme fonction d'activation non linéaire +### Utiliser *ReLU* comme fonction d'activation non linéaire -ReLU fonctionne mieux pour les réseaux à plusieurs couches, ce qui a fait que des alternatives comme la fonction sigmoïde et la fonction de tangente hyperbolique $\tanh(\cdot)$ ont perdu de leur popularité. La raison pour laquelle ReLU fonctionne le mieux est probablement due à son unique nœud qui le rend d'échelle équivalente. +*ReLU* fonctionne mieux pour les réseaux à plusieurs couches, ce qui a fait que des alternatives comme la fonction sigmoïde et la fonction de tangente hyperbolique $\tanh(\cdot)$ ont perdu de leur popularité. La raison pour laquelle *ReLU* fonctionne le mieux est probablement due à son unique nœud qui le rend d'échelle équivalente. -### Normaliser les entrées pour avoir une moyenne nulle et une variance de un +### Normaliser les entrées pour avoir une moyenne nulle et une variance de 1 -Avant d'entraîner, il est utile de normaliser chaque caractéristique d'entrée afin qu'elle ait une moyenne de zéro et un écart-type de un. Lors de l'utilisation de données d'images RVB, il est courant de prendre la moyenne et l'écart type de chaque canal individuellement et de normaliser l'image par canal. Par exemple, prenez la moyenne $m_b$ et l'écart type $\sigma_b$ de toutes les valeurs du bleu dans l'ensemble de données, puis normalisez les valeurs du bleu pour chaque image individuelle comme +Avant d'entraîner, il est utile de normaliser chaque caractéristique d'entrée afin qu'elle ait une moyenne de zéro et un écart-type de un. Lors de l'utilisation de données d'images RVB, il est courant de prendre la moyenne et l'écart-type de chaque canal individuellement et de normaliser l'image par canal. Par exemple, prenez la moyenne $m_b$ et l'écart-type $\sigma_b$ de toutes les valeurs du bleu dans l'ensemble de données, puis normalisez les valeurs du bleu pour chaque image individuelle comme $$ b_{[i,j]}^{'} = \frac{b_{[i,j]} - m_b}{\max(\sigma_b, \epsilon)} $$ -où $\epsilon$ est un nombre arbitrairement petit que nous utilisons pour éviter la division par zéro. Répétez la même chose pour les canaux verts et rouges. Ceci est nécessaire pour obtenir un signal significatif à partir d'images prises sous différents éclairages ; par exemple, les images prises en plein jour contiennent beaucoup de rouge alors que les images sous-marines n'en contiennent presque pas. +où $\epsilon$ est un nombre arbitrairement petit que nous utilisons pour éviter la division par zéro. Répétez la même chose pour les canaux verts et rouges. +Ceci est nécessaire pour obtenir un signal significatif à partir d'images prises sous différents éclairages. Par exemple, les images prises en plein jour contiennent beaucoup de rouge alors que les images sous-marines n'en contiennent presque pas. ### Initialisation des poids -Les poids doivent être initialisés au hasard, mais ils ne doivent pas être trop grands ou trop petits pour que la sortie soit à peu près de la même variance que l'entrée. PyTorch comporte plusieurs astuces d'initialisation des poids. Une des astuces qui fonctionne bien pour les modèles profonds est l'initialisation de Kaiming où la variance des poids est inversement proportionnelle à la racine carrée du nombre d'entrées. +Les poids doivent être initialisés au hasard, mais ils ne doivent pas être trop grands ou trop petits pour que la sortie soit à peu près de la même variance que l'entrée. PyTorch comporte plusieurs astuces d'initialisation des poids. Une des astuces qui fonctionne bien pour les modèles profonds est l'initialisation de Kaiming où l'écart-type des poids est inversement proportionnelle à la racine carrée du nombre d'entrées. ## Notebook Jupyter -Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning-Minicourse/blob/master/04-spiral_classification.ipynb). Pour le faire fonctionner, assurez-vous que vous avez installé l'environnement "dl-minicourse" comme indiqué dans [README.md](https://github.com/Atcold/pytorch-Deep-Learning-Minicourse/blob/master/README.md). -Une explication sur l'utilisation de `torch.device()` se trouve dans [les notes de la semaine dernière](https://atcold.github.io/pytorch-Deep-Learning-Minicourse/fr/week01/01-3/). -Comme auparavant, nous allons travailler avec des points dans $\mathbb{R}^2$ avec trois labels catégoriels différents (en rouge, jaune et bleu ) comme on peut le voir dans **Fig. 8**. +La version anglaise du *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning-Minicourse/blob/master/04-spiral_classification.ipynb). La version française se trouve pour sa part [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/04-spiral_classification.ipynb). Pour le faire fonctionner, assurez-vous que vous avez installé l'environnement "dl-minicourse" comme indiqué dans le fichier [README.md](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/docs/fr/README-FR.md). +Une explication sur l'utilisation de `torch.device()` se trouve dans [les notes de la semaine 1](https://atcold.github.io/pytorch-Deep-Learning/fr/week01/01-3/). +Comme auparavant, nous allons travailler avec des points dans $\mathbb{R}^2$ avec trois labels catégoriels différents (en rouge, jaune et bleu ) comme on peut le voir dans figure 8.
-
Fig. 8 Données de classification en spirale. +
Figure 8 : Données de classification en spirale
-`nn.Sequential()` est un conteneur, qui passe les modules au constructeur dans l'ordre où ils sont ajoutés ; `nn.linear()` est mal nommé car il applique une transformation **affine** aux données entrantes : $\boldsymbol y = \boldsymbol W \boldsymbol x + \boldsymbol b$. Pour plus d'informations, consultez la [documentation PyTorch](https://pytorch.org/docs/stable/nn.html). -N'oubliez pas qu'une transformation affine est composée de cinq choses : rotation, réflexion, translation, mise à l'échelle et cisaillement. -Comme on peut le voir sur la **Figure 9**, en essayant de séparer les données en spirale avec des limites de décision linéaires - en utilisant uniquement des modules `nn.linear()`, sans non-linéarité entre eux - le mieux que nous puissions obtenir est une précision de $50\%$. + +`nn.Sequential()` est un conteneur, qui passe les modules au constructeur dans l'ordre où ils sont ajoutés. +`nn.linear()` est mal nommé car il applique une transformation **affine** aux données entrantes : $\boldsymbol y = \boldsymbol W \boldsymbol x + \boldsymbol b$. Pour plus d'informations, consultez la [documentation PyTorch](https://pytorch.org/docs/stable/nn.html). +N'oubliez pas qu'une transformation affine est composée de cinq choses : rotation, réflexion, translation, mise à l'échelle (la scalabilité) et le *shearing*. +Comme on peut le voir sur la figure 9, en essayant de séparer les données en spirale avec des limites de décision linéaires (en utilisant uniquement des modules `nn.linear()`, sans non-linéarité entre eux) le mieux que nous puissions obtenir est une précision de $50\%$. +
-
Fig. 9 Limites de décision linéaires. +
Figure 9 : Limites de décision linéaires
-Lorsque nous passons d'un modèle linéaire à un modèle comportant deux modules `nn.linear()` et un module `nn.ReLU()` entre eux, la précision passe à 95 %. C'est parce que les limites deviennent non linéaires et s'adaptent beaucoup mieux à la forme en spirale des données, comme on peut le voir sur la **Fig. 10**. +Lorsque nous passons d'un modèle linéaire à un modèle comportant deux modules `nn.linear()` et un module `nn.ReLU()` entre eux, la précision passe à 95 %. C'est parce que les limites deviennent non linéaires et s'adaptent beaucoup mieux à la forme en spirale des données, comme on peut le voir sur la figure 10. +
-
Fig. 10 Limites de décision non linéaires. +
+Figure 10 : Limites de décision non linéaires
-Un exemple de problème de régression qui ne peut pas être résolu correctement par une régression linéaire, mais qui est facilement résolu avec la même structure de réseau neuronal peut être vu dans [ce notebook](https://github.com/Atcold/pytorch-Deep-Learning-Minicourse/blob/master/05-regression.ipynb) et dans la **Fig. 11**, qui montre 10 réseaux différents, où 5 ont une fonction de lien `nn.ReLU()` et 5 ont une fonction de lien `nn.Tanh()`. La première est une fonction linéaire par morceaux, tandis que la seconde est une régression continue et régulière. +Un exemple de problème de régression qui ne peut pas être résolu correctement par une régression linéaire, mais qui est facilement résolu avec la même structure de réseau neuronal peut être vu dans [ce notebook](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/05-regression.ipynb) et dans la figure 11 qui montre 10 réseaux différents, où 5 ont une fonction `nn.ReLU()` et 5 ont une fonction `nn.Tanh()`. La première est une fonction linéaire par morceaux, tandis que la seconde est une régression continue et régulière. +
-
Fig. 11 : 10 réseaux de neurones, avec leur variance et leur écart-type.
-A gauche : cinq ReLU réseaux. A droite : Cinq tanh réseaux. +
Figure 11 : 10 réseaux de neurones, avec leur variance et leur écart-type.
+A gauche : cinq réseaux avec une ReLU. A droite : Cinq réseaux avec une tanh.
-Les lignes jaune et verte indiquent l'écart type et la variance des réseaux. Leur utilisation est utile pour quelque chose de similaire à un "intervalle de confiance", puisque les fonctions donnent une seule prédiction par sortie. L'utilisation de la prédiction de la variance d'ensemble nous permet d'estimer l'incertitude avec laquelle la prédiction est faite. L'importance de cette fonction est illustrée par la **Figure 12**, où nous étendons les fonctions de décision en dehors de l'intervalle d'entraînement et où celles-ci tendent vers $+\infty, -\infty$. + +Les lignes jaune et verte indiquent l'écart-type et la variance des réseaux. Leur utilisation est utile pour quelque chose de similaire à un "intervalle de confiance", puisque les fonctions donnent une seule prédiction par sortie. L'utilisation de la prédiction de la variance d'ensemble nous permet d'estimer l'incertitude avec laquelle la prédiction est faite. L'importance de cette fonction est illustrée par la figure 12 où nous étendons les fonctions de décision en dehors de l'intervalle d'entraînement et où celles-ci tendent vers $+\infty, -\infty$. +
-
Fig. 12 Réseaux de neurones, avec moyenne et écart-type, en dehors de l'intervalle d'entraînement.
-A gauche : cinq ReLU réseaux. A droite : Cinq tanh réseaux. +
Figure 12 : Réseaux de neurones, avec moyenne et écart-type, en dehors de l'intervalle d'entraînement.
+A gauche : cinq réseaux avec une ReLU. A droite : Cinq réseaux avec une tanh.
+ Pour entraîner un réseau de neurones à l'aide de PyTorch, il faut suivre 5 étapes fondamentales dans la boucle d'entraînement : 1. `output = model(input)` est la passe en avant du modèle, qui prend l'entrée et génère la sortie. 2. `J = loss(output, target label)` prend la sortie du modèle et calcule la perte d'entraînement par rapport à la véritable cible. -3. `model.zero_grad()` nettoie les calculs de gradient, afin qu'ils ne soient pas accumulés pour la prochaine passe. -4. `J.backward()` fait la rétropropagation et l'accumulation : Il calcule $\nabla_\texttt{x} J$ pour chaque variable $\texttt{x}$ pour laquelle nous avons spécifié `requires_grad=True`. Elles sont cumulées dans le gradient de chaque variable : $\texttt{x.grad} \gets \texttt{x.grad} + \nabla_\texttt{x} J$. +3. `model.zero_grad()` nettoie les calculs du gradient afin qu'ils ne soient pas accumulés pour la prochaine passe. +4. `J.backward()` fait la rétropropagation et l'accumulation. Il calcule $\nabla_\texttt{x} J$ pour chaque variable $\texttt{x}$ pour laquelle nous avons spécifié `requires_grad=True`. Elles sont cumulées dans le gradient de chaque variable : $\texttt{x.grad} \gets \texttt{x.grad} + \nabla_\texttt{x} J$. 5. `optimiser.step()` fait un pas dans la descente de la pente : $\vartheta \gets \vartheta - \eta\, \nabla_\vartheta J$. Lors de l'entraînement d'un réseau, il est très probable que vous ayez besoin de ces 5 étapes dans l'ordre où elles ont été présentées. diff --git a/docs/fr/week02/02.md b/docs/fr/week02/02.md index 8b8a4669b..a4e8278fb 100644 --- a/docs/fr/week02/02.md +++ b/docs/fr/week02/02.md @@ -13,7 +13,7 @@ We start by understanding what parametrised models are and then discuss what a l --> -## Conférence partie A +## Cours magistral partie A Nous commençons par comprendre ce que sont les modèles paramétrés, puis nous discutons de ce qu'est une fonction de perte. Nous examinons ensuite les méthodes basées sur les gradients et leur utilisation dans l'algorithme de rétropropagation d'un réseau neuronal traditionnel. Nous concluons cette section en apprenant comment mettre en œuvre un réseau de neurones dans PyTorch, puis nous discutons d'une forme plus généralisée de rétropropagation. @@ -23,7 +23,7 @@ Nous commençons par comprendre ce que sont les modèles paramétrés, puis nous We begin with a concrete example of backpropagation and discuss the dimensions of Jacobian matrices. We then look at various basic neural net modules and compute their gradients, followed by a brief discussion on softmax and logsoftmax. The other topic of discussion in this part is Practical Tricks for backpropagation. --> -## Conférence partie B +## Cours magistral partie B Nous commençons par un exemple concret de rétropropagation et discutons des dimensions des matrices jacobiennes. Nous examinons ensuite divers modules de base des réseaux de neurones et calculons leurs gradients, puis nous discutons brièvement de softmax et de logsoftmax. L'autre sujet de discussion dans cette partie est celui des astuces pratiques pour la rétropropagation. @@ -33,7 +33,6 @@ Nous commençons par un exemple concret de rétropropagation et discutons des di We give a brief introduction to supervised learning using artificial neural networks. We expound on the problem formulation and conventions of data used to train these networks. We also discuss how to train a neural network for multi class classification, and how to perform inference once the network is trained. --> -## Pratique +## Travaux dirigés Nous présentons brièvement l'apprentissage supervisé à l'aide de réseaux neuronaux artificiels. Nous exposons la formulation du problème et les conventions des données utilisées pour entraîner ces réseaux. Nous discutons également de la manière d’entraîner un réseau neuronal pour la classification multi-classes, et de la manière d'effectuer l'inférence une fois le réseau entraîné. - diff --git a/docs/fr/week03/03-1.md b/docs/fr/week03/03-1.md index 7aca079a1..0782f6678 100644 --- a/docs/fr/week03/03-1.md +++ b/docs/fr/week03/03-1.md @@ -42,26 +42,26 @@ This provides us with some insight into why the 2-neuron hidden layers are harde Dans cette section, nous allons visualiser le fonctionnement interne d'un réseau de neurones.
Network
-Fig. 1 Structure du réseau
+Figure 1 : Structure du réseau
-La figure 1 illustre la structure du réseau de neurones que nous souhaitons visualiser. En général, lorsque nous dessinons la structure d'un réseau de neurones, l'entrée apparaît en bas ou à gauche, et la sortie apparaît en haut ou à droite. Dans la figure 1, les neurones roses représentent les entrées, et les neurones bleus les sorties. Dans ce réseau, nous avons 4 couches cachées (en vert), ce qui signifie que nous avons 6 couches au total (4 couches cachées + 1 couche d'entrée + 1 couche de sortie). Dans ce cas, nous avons 2 neurones par couche cachée, et donc la dimension de la matrice de poids ($W$) pour chaque couche est de 2 par 2. Cela s'explique par le fait que nous voulons transformer notre plan d'entrée en un autre plan que nous pouvons visualiser. +La figure 1 illustre la structure du réseau de neurones que nous souhaitons visualiser. En général, lorsque nous dessinons la structure d'un réseau de neurones, l'entrée apparaît en bas ou à gauche et la sortie apparaît en haut ou à droite. Dans la figure 1, les neurones roses représentent les entrées et les neurones bleus les sorties. Dans ce réseau, nous avons 4 couches cachées (en vert), ce qui signifie que nous avons 6 couches au total (4 couches cachées + 1 couche d'entrée + 1 couche de sortie). Dans ce cas, nous avons 2 neurones par couche cachée et donc la dimension de la matrice de poids ($W$) pour chaque couche est de 2 par 2. Cela s'explique par le fait que nous voulons transformer notre plan d'entrée en un autre plan que nous pouvons visualiser.
Network
-Fig. 2 Visualisation de l'espace de pliage
+Figure 2 : Visualisation de l'espace de pliage -La transformation de chaque couche est comme le pliage de notre avion dans certaines régions spécifiques, comme le montre la figure 2. Ce pliage est très abrupt, car toutes les transformations sont effectuées dans la couche 2D. Dans l'expérience, nous constatons que si nous n'avons que 2 neurones dans chaque couche cachée, l'optimisation prendra plus de temps ; l'optimisation est plus facile si nous avons plus de neurones dans les couches cachées. Cela nous laisse avec une question importante à considérer : pourquoi est-il plus difficile d’entraîner le réseau avec moins de neurones dans les couches cachées ? Vous devriez réfléchir vous-même à cette question et nous y reviendrons après la visualisation de la fonction $\texttt{ReLU}$. +La transformation de chaque couche est comme le pliage de notre paln dans certaines régions spécifiques, comme le montre la figure 2. Ce pliage est très abrupt, car toutes les transformations sont effectuées dans la couche 2D. Dans l'expérience, nous constatons que si nous n'avons que 2 neurones dans chaque couche cachée, l'optimisation prendra plus de temps. L'optimisation est plus facile si nous avons plus de neurones dans les couches cachées. Cela nous laisse avec une question importante à considérer : pourquoi est-il plus difficile d’entraîner le réseau avec moins de neurones dans les couches cachées ? | Réseau | Réseau | |(a)|(b)| -
Fig. 3 Visualisation de l'opérateur ReLU
+
Figure 3 : Visualisation de l'opérateur ReLU
-Lorsque nous parcourons le réseau une couche cachée à la fois, nous constatons qu'avec chaque couche, nous effectuons une certaine transformation affine suivie de l'application de l'opération ReLU non linéaire, qui élimine toute valeur négative. Dans les figures 3(a) et (b), nous pouvons voir la visualisation de l'opérateur ReLU. L'opérateur ReLU nous aide à effectuer des transformations non linéaires. Après avoir effectué plusieurs étapes de transformation affine suivies par l'opérateur ReLU, nous sommes finalement en mesure de séparer les données de manière linéaire, comme le montre la figure 4. +Lorsque nous parcourons le réseau une couche cachée à la fois, nous constatons qu'avec chaque couche, nous effectuons une certaine transformation affine suivie de l'application de l'opération *ReLU* non linéaire, qui élimine toute valeur négative. Dans les figures 3(a) et (b), nous pouvons voir la visualisation de l'opérateur *ReLU*. L'opérateur *ReLU* nous aide à effectuer des transformations non linéaires. Après avoir effectué plusieurs étapes de transformation affine suivies par l'opérateur *ReLU*, nous sommes finalement en mesure de séparer les données de manière linéaire, comme le montre la figure 4.
Network
-Fig. 4 Visualisation des résultats
+Figure 4 : Visualisation des résultats -Cela nous permet de comprendre pourquoi les couches cachées des deux neurones sont plus difficiles à entraîner. Notre réseau à 6 couches a un biais dans chaque couche cachée. Par conséquent, si l'un de ces biais déplace des points hors du quadrant supérieur droit, l'application de l'opérateur ReLU éliminera ces points. Ensuite, quelle que soit la façon dont les couches ultérieures transforment les données, les valeurs resteront nulles. Nous pouvons rendre un réseau de neurones plus facile à entraîner en rendant le réseau plus "gros" (c'est-à-dire en ajoutant plus de neurones dans les couches cachées) ou nous pouvons ajouter d'autres couches cachées, ou une combinaison des deux méthodes. Tout au long de ce cours, nous explorerons comment déterminer la meilleure architecture de réseau pour un problème donné, restez à l'écoute. +Cela nous permet de comprendre pourquoi les couches cachées des deux neurones sont plus difficiles à entraîner. Notre réseau à 6 couches a un biais dans chaque couche cachée. Par conséquent, si l'un de ces biais déplace des points hors du quadrant supérieur droit, l'application de l'opérateur *ReLU* éliminera ces points. Ensuite, quelle que soit la façon dont les couches ultérieures transforment les données, les valeurs resteront nulles. Nous pouvons rendre un réseau de neurones plus facile à entraîner en rendant le réseau plus "gros" (c'est-à-dire en ajoutant plus de neurones dans les couches cachées) ou nous pouvons ajouter d'autres couches cachées, ou une combinaison des deux méthodes. ### Détection de motifs dans les données séquentielles -La transformation de partage de poids peut être appliquée à la détection de motifs. La détection de motifs consiste à trouver certains motifs dans des données séquentielles comme des mots-clés dans la parole ou le texte. Une façon d'y parvenir, comme le montre la figure 7, consiste à utiliser une fenêtre coulissante sur les données, qui déplace la fonction de partage de poids pour détecter un motif particulier (c'est-à-dire un son particulier dans le signal vocal), et les sorties (c'est-à-dire une partition) passent dans une fonction maximale. +La transformation de partage de poids peut être appliquée à la détection de motifs. La détection de motifs consiste à trouver certains motifs dans des données séquentielles comme des mots-clés dans la parole ou le texte. Une façon d'y parvenir, comme le montre la figure 7, consiste à utiliser une fenêtre coulissante sur les données, qui déplace la fonction de partage de poids pour détecter un motif particulier (c'est-à-dire un son particulier dans le signal vocal) et les sorties (c'est-à-dire une partition) passent dans une fonction maximale.
Network
-Fig. 7 Détection des motifs pour les données séquentielles
+Figure 7 : Détection des motifs pour les données séquentielles -Dans cet exemple, nous avons 5 de ces fonctions. Cette solution nous permet d'additionner cinq gradients et de rétropropager l'erreur pour mettre à jour le paramètre $w$. En implémentant cela dans PyTorch, nous voulons empêcher l'accumulation implicite de ces gradients, donc nous devons utiliser `zero_grad()` pour initialiser le gradient. +Dans cet exemple, nous avons cinq de ces fonctions. Cette solution nous permet d'additionner cinq gradients et de rétropropager l'erreur pour mettre à jour le paramètre $w$. En implémentant cela dans PyTorch, nous voulons empêcher l'accumulation implicite de ces gradients, donc nous devons utiliser `zero_grad()` pour initialiser le gradient. -### Les torsions régulières qui peuvent être faites avec l'opérateur convolutif dans les ConvNets profonds +### Les torsions de base qui peuvent être réalisées avec l'opérateur convolutif dans les ConvNets profonds -1. **Décalage** (Striding) : au lieu de décaler la fenêtre en $x$ une entrée à la fois, on peut le faire avec un pas plus grand (par exemple deux ou trois entrées à la fois). -Exemple : Supposons que l'entrée $x$ soit unidimensionnelle et ait une taille de 100 et que $w$ ait une taille de 5. La taille de la sortie avec un pas de 1 ou 2 est indiquée dans le tableau ci-dessous : +- **Décalage** (*striding*) : au lieu de décaler la fenêtre en $x$ une entrée à la fois, on peut le faire avec un pas plus grand (par exemple deux ou trois entrées à la fois). +Exemple : supposons que l'entrée $x$ soit unidimensionnelle et ait une taille de 100 et que $w$ ait une taille de 5. La taille de la sortie avec un pas de 1 ou 2 est indiquée dans le tableau ci-dessous : | Pas | 1 | 2 | | ------------ | -------------------------- | -------------------------- | @@ -284,7 +285,7 @@ Exemple : Supposons que l'entrée $x$ soit unidimensionnelle et ait une taille d -2. **Remplissage** (Padding) : Très souvent, dans la conception des architectures de réseaux neuronaux profonds, nous voulons que la sortie de la convolution soit de la même taille que l'entrée. Cela peut être réalisé en ajoutant aux extrémités de l'entrée un certain nombre d'entrées (généralement) nulles, généralement des deux côtés. Le remplissage se fait surtout par commodité. Il peut parfois avoir un impact sur les performances et entraîner d'étranges effets de bord, cela dit, lorsqu'on utilise une non-linéarité ReLU, le remplissage avec des zéros n'est pas déraisonnable. +- **Remplissage** (*padding*) : très souvent, dans la conception des architectures de réseaux neuronaux profonds, nous voulons que la sortie de la convolution soit de la même taille que l'entrée. Cela peut être réalisé en ajoutant aux extrémités de l'entrée un certain nombre d'entrées (généralement) nulles, généralement des deux côtés. Le remplissage se fait surtout par commodité. Il peut parfois avoir un impact sur les performances et entraîner d'étranges effets de bord, cela dit, lorsqu'on utilise une non-linéarité *ReLU*, le remplissage avec des zéros n'est pas déraisonnable. -## [Proto- ConvNets et evolution vers les ConvNets modernes](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=2949s) +## [Proto-ConvNets et evolution vers les ConvNets modernes](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=2949s) -### ConvNets avec pooling +### ConvNets avec *pooling* -L'année suivante, certains changements ont été apportés : un pooling séparé a été introduit. Le pooling séparé est réalisé en faisant la moyenne des valeurs en entrée, en ajoutant un biais et en passant à une fonction non linéaire (fonction tangente hyperbolique). Le pooling de taille 2$\times$2 a été effectuée avec un pas de 2, réduisant ainsi les résolutions de moitié. +L'année suivante, certains changements ont été apportés : un *pooling* séparé a été introduit. Le *pooling* séparé est réalisé en faisant la moyenne des valeurs en entrée, en ajoutant un biais et en passant à une fonction non linéaire (fonction tangente hyperbolique). Le *pooling* de taille 2$\times$2 a été effectuée avec un pas de 2, réduisant ainsi les résolutions de moitié.

- Fig. 1 Architecture ConvNet + Figure 1 : Architecture ConvNet
Voici un exemple de couche convolutionnelle unique : 1. On prend une entrée de taille *32$\times$32* 2. La couche de convolution passe un noyau de taille 5$\times$5 avec un pas de 1 sur l'image, ce qui donne une feature map de taille *28$\times$28*. 3. On passe la feature map à travers une fonction non linéaire : taille *28$\times$28* -4. On passe à la couche de pooling qui fait une moyenne sur une fenêtre de 2$\times$2 avec un pas de 2 : taille *14$\times$14* +4. On passe à la couche de *pooling* qui fait une moyenne sur une fenêtre de 2$\times$2 avec un pas de 2 : taille *14$\times$14* 5. On répéte des étapes 1 à 4 pour 4 noyaux -Les combinaisons simples convolution/pooling de la première couche détectent généralement des caractéristiques simples, telles que des bords orientés. Après la première couche de convolution/pooling, l'objectif est de détecter des combinaisons d'éléments des couches précédentes. Pour ce faire, les étapes 2 à 4 sont répétées avec plusieurs noyaux sur les cartes de caractéristiques des couches précédentes, et sont additionnées dans une nouvelle carte de caractéristiques (feature map en anglais) : +Les combinaisons simples convolution/*pooling* de la première couche détectent généralement des caractéristiques simples, telles que des bords orientés. Après la première couche de convolution/*pooling*, l'objectif est de détecter des combinaisons d'éléments des couches précédentes. Pour ce faire, les étapes 2 à 4 sont répétées avec plusieurs noyaux sur les cartes de caractéristiques des couches précédentes, et sont additionnées dans une nouvelle carte de caractéristiques : -1. Un nouveau noyau de 5$\times$5 est glissé sur toutes les feature map des couches précédentes, et les résultats sont additionnés. (Note : dans l'expérience de Yann en 1989, la connexion n'est pas complète pour les calculs. Les paramètres modernes imposent généralement des connexions complètes) : taille *10$\times$10* +1. Un nouveau noyau de 5$\times$5 est glissé sur toutes les cartes de caractéristiques des couches précédentes, et les résultats sont additionnés. Note : dans l'expérience de Yann en 1989, la connexion n'est pas complète pour les calculs. Les paramètres modernes imposent généralement des connexions complètes : taille *10$\times$10* 2. On passe la sortie de la convolution à une fonction non linéaire : taille *10$\times$10* 3. On répète les étapes 1 et 2 pour 16 noyaux. -4. On passe le résultat à la couche de pooling qui moyenne sur une fenêtre de taille 2$\times$2 avec un pas de 2 : taille *5$\times$5* de chaque feature map +4. On passe le résultat à la couche de *pooling* qui moyenne sur une fenêtre de taille 2$\times$2 avec un pas de 2 : taille *5$\times$5* de chaque cartes de caractéristiques Pour générer une sortie, on effectue la dernière couche de convolution, qui semble être une connexion complète mais qui est en fait convolutive. -1. La dernière couche de convolution fait glisser un noyau de 5$\times$5 sur toutes les feature map, avec des résultats résumés : taille *1$\times$1* +1. La dernière couche de convolution fait glisser un noyau de 5$\times$5 sur toutes les cartes de caractéristiques, avec des résultats résumés : taille *1$\times$1* 2. Passage par une fonction non linéaire : taille *1$\times$1* 3. Générer la sortie unique pour une catégorie. 4. Répétez toutes les étapes précédentes pour chacune des 10 catégories (en parallèle) -Voir [cette animation](http://cs231n.github.io/convolutional-networks/) sur le site d'Andrej Karpathy sur la façon dont les convolutions modifient la forme des feature map de la couche suivante. L'article complet est disponible [ici](https://papers.nips.cc/paper/293-handwritten-digit-recognition-with-a-back-propagation-network.pdf). +Voir [cette animation](http://cs231n.github.io/convolutional-networks/) sur le site d'Andrej Karpathy sur la façon dont les convolutions modifient la forme des cartes de caractéristiques de la couche suivante. L'article complet est disponible [ici](https://papers.nips.cc/paper/293-handwritten-digit-recognition-with-a-back-propagation-network.pdf). @@ -147,10 +147,10 @@ As demonstrated by the animation on the slides(here's another example), translat

- Fig. 2 Équivariance des changements + Figure 2 : Équivariance des changements
-Comme le montre l'animation sur les diapositives (voici un autre exemple), la translation de l'image d'entrée entraîne la même translation des feature map. Cependant, les changements dans les feature maps sont mis à l'échelle par des opérations de convolution/pooling. Par exemple, le pooling 2$\times$2 de pas 2 réduira le décalage de 1 pixel de la couche d'entrée à 0,5 pixel dans les feature map suivantes. La résolution spatiale est alors échangée contre un plus grand nombre de types d'éléments, ce qui rend la représentation plus abstraite et moins sensible aux décalages et aux distorsions. +Comme le montre l'animation sur les diapositives (voici un autre exemple), la translation de l'image d'entrée entraîne la même translation des cartes de caractéristiques. Cependant, les changements dans les cartes de caractéristiques sont mis à l'échelle par des opérations de convolution/*pooling*. Par exemple, le *pooling* 2$\times$2 de pas 2 réduira le décalage de 1 pixel de la couche d'entrée à 0,5 pixel dans les cartes de caractéristiques suivantes. La résolution spatiale est alors échangée contre un plus grand nombre de types d'éléments, ce qui rend la représentation plus abstraite et moins sensible aux décalages et aux distorsions. . Moreover, this is a demonstration of the fact that if we increase the size of the input, we will increase the size of every layer, proving CNNs' capability in handling dynamic length inputs. +Let’s assume we add 4 units at the input layer (pink units above), so that we can get 4 more units after the first convolution layer, 2 more units after the first pooling layer, 2 more units after the second convolution layer, and 1 more output. Therefore, window size to generate a new output is 4 (2 stride $\times$2) ### Exemple : longueur d'entrée dynamique -Nous pouvons construire un ConvNet avec 2 couches de convolution avec un pas de 1 et deux couches de pooling avec un pas de 2 de telle sorte que le pas global soit de 4. Ainsi, si nous voulons obtenir une nouvelle sortie, nous devons décaler notre fenêtre d'entrée de 4. Pour être plus explicite, nous pouvons voir la figure ci-dessous (unités vertes). Tout d'abord, nous avons une entrée de taille 10, et nous effectuons une convolution de taille 3 pour obtenir 8 unités. Ensuite, nous effectuons un pooling de taille 2 pour obtenir 4 unités. De même, nous répétons la convolution et le pooling et nous obtenons finalement une sortie de taille 1. +Nous pouvons construire un ConvNet avec 2 couches de convolution avec un pas de 1 et deux couches de *pooling* avec un pas de 2 de telle sorte que le pas global soit de 4. Ainsi, si nous voulons obtenir une nouvelle sortie, nous devons décaler notre fenêtre d'entrée de 4. Pour être plus explicite, nous pouvons voir la figure ci-dessous (unités vertes). Tout d'abord, nous avons une entrée de taille 10, et nous effectuons une convolution de taille 3 pour obtenir 8 unités. Ensuite, nous effectuons un *pooling* de taille 2 pour obtenir 4 unités. De même, nous répétons la convolution et le *pooling* et nous obtenons finalement une sortie de taille 1.

- Fig. 5 Architecture ConvNet sur la liaison de la taille d'entrée des variantes + Figure 5 : Architecture ConvNet sur la liaison de la taille d'entrée des variantes
-Supposons que nous ajoutions 4 unités à la couche d'entrée (unités roses au-dessus), de sorte que nous puissions obtenir 4 unités supplémentaires après la première couche de convolution, 2 unités supplémentaires après la première couche de pooling, 2 unités supplémentaires après la deuxième couche de convolution et 1 unité supplémentaire en sortie. Par conséquent, la taille de la fenêtre pour générer une nouvelle sortie est de 4 (2 pas $\times$2) . De plus, cela démontre que si nous augmentons la taille de l'entrée, nous augmenterons la taille de chaque couche, ce qui prouve la capacité des ConvNets à gérer les entrées de longueur dynamique. +Supposons que nous ajoutions 4 unités à la couche d'entrée (unités roses au-dessus), de sorte que nous puissions obtenir 4 unités supplémentaires après la première couche de convolution, 2 unités supplémentaires après la première couche de *pooling*, 2 unités supplémentaires après la deuxième couche de convolution et 1 unité supplémentaire en sortie. Par conséquent, la taille de la fenêtre pour générer une nouvelle sortie est de 4 (deux fois 2 pas) . De plus, cela démontre que si nous augmentons la taille de l'entrée, nous augmenterons la taille de chaque couche, ce qui prouve la capacité des ConvNets à gérer les entrées de longueur dynamique. -## Pour quoi les ConvNets sont performants ? -Les ConvNets sont performants pour les signaux naturels qui se présentent sous la forme de réseaux multidimensionnels et ont trois propriétés principales : -1. **1. La localisation** : La première est qu'il existe une forte corrélation locale entre les valeurs. Si nous prenons deux pixels proches d'une image naturelle, il est très probable que ces pixels aient la même couleur. Plus deux pixels sont éloignés l'un de l'autre, plus la similitude entre eux diminue. Les corrélations locales peuvent nous aider à détecter des caractéristiques locales, ce que font les ConvNets. Si nous alimentons le ConvNet avec des pixels permutés, il ne sera pas performant dans la reconnaissance des images d'entrée, tandis que le FC ne sera pas affecté. La corrélation locale justifie les connexions locales. -2. **Stationnarité** : Le deuxième caractère est que les caractéristiques sont essentielles et peuvent apparaître n'importe où sur l'image, justifiant les poids partagés et le pooling. De plus, les signaux statistiques sont uniformément distribués, ce qui signifie que nous devons répéter la détection des caractéristiques pour chaque emplacement sur l'image d'entrée. -3. **Compostionalité** : Le troisième caractère est que les images naturelles sont compositionnelles, ce qui signifie que les caractéristiques composent une image de manière hiératique. Cela justifie l'utilisation de plusieurs couches de neurones, ce qui correspond aussi étroitement aux recherches de Hubel et Weisel sur les cellules simples et complexes. +## Pour quelles taches les ConvNets sont performants ? +Les ConvNets sont performants pour les signaux naturels qui se présentent sous la forme de réseaux multidimensionnels et ont trois propriétés principales : +1. **La localisation** : la première est qu'il existe une forte corrélation locale entre les valeurs. Si nous prenons deux pixels proches d'une image naturelle, il est très probable que ces pixels aient la même couleur. Plus deux pixels sont éloignés l'un de l'autre, plus la similitude entre eux diminue. Les corrélations locales peuvent nous aider à détecter des caractéristiques locales, ce que font les ConvNets. Si nous alimentons le ConvNet avec des pixels permutés, il ne sera pas performant dans la reconnaissance des images d'entrée, tandis que le FC ne sera pas affecté. La corrélation locale justifie les connexions locales. +2. **La stationnarité** : le deuxième caractère est que les caractéristiques sont essentielles et peuvent apparaître n'importe où sur l'image, justifiant les poids partagés et le *pooling*. De plus, les signaux statistiques sont uniformément distribués, ce qui signifie que nous devons répéter la détection des caractéristiques pour chaque emplacement sur l'image d'entrée. +3. **La compostionalité** : le troisième caractère est que les images naturelles sont compositionnelles, ce qui signifie que les caractéristiques composent une image de manière hiératique. Cela justifie l'utilisation de plusieurs couches de neurones, ce qui correspond aussi étroitement aux recherches de Hubel et Weisel sur les cellules simples et complexes. En outre, les ConvNets sont utilisés sur les vidéos, les images, les textes et la reconnaissance vocale. diff --git a/docs/fr/week03/03-3.md b/docs/fr/week03/03-3.md index 9e2f721dc..6ef1e5bd7 100644 --- a/docs/fr/week03/03-3.md +++ b/docs/fr/week03/03-3.md @@ -36,9 +36,9 @@ Une image est un signal 2D parce que l'information est représentée dans l'espa Nous pouvons même représenter le langage avec la logique ci-dessus. Chaque mot correspond à un vecteur one-hot avec un à la position où il se trouve dans notre vocabulaire et des zéros partout ailleurs. Cela signifie que chaque mot est un vecteur de la taille du vocabulaire. Les signaux de données naturels suivent ces propriétés : -1. Stationnarité : Certains motifs se répètent tout au long d'un signal. Dans les signaux audio, nous observons le même type de motifs encore et encore dans le domaine temporel. Dans les images, cela signifie que nous pouvons nous attendre à ce que des motifs visuels similaires se répètent dans toute la dimensionnalité. -2. Localité : Les points proches sont plus corrélés que les points éloignés. Pour un signal 1D, cela signifie que si nous observons un pic à un certain point $t_i$, nous nous attendons à ce que les points dans une petite fenêtre autour de $t_i$ aient des valeurs similaires à $t_i$ mais pour un point $t_j$ éloigné de $t_i$, $x_{t_i}$ a très peu d'influence sur $x_{t_j}$. Plus formellement, la convolution entre un signal et son homologue inversé a un pic lorsque le signal chevauche parfaitement sa version inversée. Une convolution entre deux signaux 1D (corrélation croisée) n'est rien d'autre que le produit de leur point, qui est une mesure de la similarité ou de la proximité des deux vecteurs. Ainsi, l'information est contenue dans des portions et des parties spécifiques du signal. Pour les images, cela signifie que la corrélation entre deux points dans une image diminue à mesure que l'on s'éloigne des points. Si le pixel $x_{0,0}$ est bleu, la probabilité que le pixel suivant ($x_{1,0},x_{0,1}$) soit également bleu est assez élevée, mais lorsque l'on se déplace vers l'extrémité opposée de l'image ($x_{-1,-1}$), la valeur de ce pixel est indépendante de la valeur du pixel à $x_{0,0}$. -3. Composition : Tout dans la nature est composé de parties qui sont composées de sous-parties et ainsi de suite. Par exemple, les caractères forment des chaînes de caractères qui forment des mots, qui forment ensuite des phrases. Les phrases peuvent être combinées pour former des documents. La composition permet d'expliquer le monde. +1. Stationnarité : certains motifs se répètent tout au long d'un signal. Dans les signaux audio, nous observons le même type de motifs encore et encore dans le domaine temporel. Dans les images, cela signifie que nous pouvons nous attendre à ce que des motifs visuels similaires se répètent dans toute la dimensionnalité. +2. Localité : les points proches sont plus corrélés que les points éloignés. Pour un signal 1D, cela signifie que si nous observons un pic à un certain point $t_i$, nous nous attendons à ce que les points dans une petite fenêtre autour de $t_i$ aient des valeurs similaires à $t_i$ mais pour un point $t_j$ éloigné de $t_i$, $x_{t_i}$ a très peu d'influence sur $x_{t_j}$. Plus formellement, la convolution entre un signal et son homologue inversé a un pic lorsque le signal chevauche parfaitement sa version inversée. Une convolution entre deux signaux 1D (corrélation croisée) n'est rien d'autre que le produit de leur point, qui est une mesure de la similarité ou de la proximité des deux vecteurs. Ainsi, l'information est contenue dans des portions et des parties spécifiques du signal. Pour les images, cela signifie que la corrélation entre deux points dans une image diminue à mesure que l'on s'éloigne des points. Si le pixel $x_{0,0}$ est bleu, la probabilité que le pixel suivant ($x_{1,0},x_{0,1}$) soit également bleu est assez élevée, mais lorsque l'on se déplace vers l'extrémité opposée de l'image ($x_{-1,-1}$), la valeur de ce pixel est indépendante de la valeur du pixel à $x_{0,0}$. +3. Composition : tout dans la nature est composé de parties qui sont composées de sous-parties et ainsi de suite. Par exemple, les caractères forment des chaînes de caractères qui forment des mots, qui forment ensuite des phrases. Les phrases peuvent être combinées pour former des documents. La composition permet d'expliquer le monde. Si nos données sont stationnaires, locales et composées, nous pouvons les exploiter grâce à des réseaux qui utilisent l’ éparsité, le partage du poids et l'empilement des couches. @@ -69,12 +69,12 @@ If our data exhibits locality, each neuron needs to be connected to only a few l La figure 1 montre un réseau à 5 couches entièrement connecté. Chaque flèche représente un poids à multiplier par les entrées. Comme on peut le voir, ce réseau est très coûteux en termes de calcul.

-Figure 1: Réseau entièrement connecté
+Figure 1 : Réseau entièrement connecté -Si nos données montrent une localité, chaque neurone doit être connecté à seulement quelques neurones locaux de la couche précédente. Ainsi, certaines connexions peuvent être supprimées comme le montre la figure 2. La Fig.2(a) représente un réseau FC. En profitant de la propriété de localisation de nos données, nous supprimons les connexions entre les neurones éloignés dans la Fig.2(b). Bien que les neurones de la couche cachée (vert) de la figure 2(b) ne couvrent pas la totalité de l'entrée, l'architecture globale pourra prendre en compte tous les neurones d'entrée. Le champ réceptif (abrégé RF en anglais pour receptive field) est le nombre de neurones des couches précédentes, que chaque neurone d'une couche particulière peut voir ou a pris en compte. Par conséquent, le RF de la couche de sortie est de 3 pour la couche cachée, le RF de la couche cachée est de 3 pour la couche d'entrée, mais le RF de la couche de sortie est de 5 pour la couche d'entrée. +Si nos données montrent une localité, chaque neurone doit être connecté à seulement quelques neurones locaux de la couche précédente. Ainsi, certaines connexions peuvent être supprimées comme le montre la figure 2. La figure 2(a) représente un réseau FC. En profitant de la propriété de localisation de nos données, nous supprimons les connexions entre les neurones éloignés dans la figure 2(b). Bien que les neurones de la couche cachée (vert) de la figure 2(b) ne couvrent pas la totalité de l'entrée, l'architecture globale pourra prendre en compte tous les neurones d'entrée. Le champ réceptif (abrégé RF pour *receptive field* en anglais) est le nombre de neurones des couches précédentes, que chaque neurone d'une couche particulière peut voir ou a pris en compte. Par conséquent, le RF de la couche de sortie est de 3 pour la couche cachée, le RF de la couche cachée est de 3 pour la couche d'entrée, mais le RF de la couche de sortie est de 5 pour la couche d'entrée. | | | -|Figure 2(a): Avant l'application de la méthode de réduction de la pauvreté | Figure 2(b): Après l'application de la méthode de réduction de la pauvreté +|Figure 2(a) : Avant l'application de la méthode de réduction de la pauvreté | Figure 2(b) : Après l'application de la méthode de réduction de la pauvreté -### Padding (Rembourrage) +### Rembourrage (*padding*) Le rembourrage nuit généralement aux résultats finaux, mais il est pratique du point de vue programmatique. Nous utilisons généralement le zero-padding: `size = (taille du noyau - 1)/2`. @@ -169,12 +169,12 @@ Un ConvNet spatial standard a les propriétés suivantes : * Couches multiples * Convolution - * Non-linéarité (ReLU et Leaky) - * Pooling - * Batch normalisation -* Residual bypass connection + * Non-linéarité (*ReLU* et *Leaky*) + * *Pooling* + * Normalisation par batch +* Connexion résiduelle -La Batch normalisation et les Residual bypass connection sont très utiles pour que le réseau s'entraîne bien. +La normalisation par batch et les connexions résiduelles sont très utiles pour que le réseau s'entraîne bien. Des parties d'un signal peuvent être perdues si trop de couches ont été empilées, de sorte que des connexions via residual bypass garantissent un chemin de bas en haut et aussi un chemin pour les gradients venant de haut en bas. Dans la figure 5, alors que l'image d'entrée contient principalement des informations spatiales en deux dimensions (à part les informations caractéristiques, qui sont la couleur de chaque pixel), la couche de sortie est épaisse. À mi-chemin, il y a un compromis entre les informations spatiales et les informations caractéristiques et la représentation devient plus dense. Par conséquent, à mesure que nous montons dans la hiérarchie, nous obtenons une représentation plus dense car nous perdons les informations spatiales. @@ -201,7 +201,7 @@ Pooling is not parametrized; nevertheless, we can choose different polling types

Figure 6: Illustration du Pooling
-Un opérateur spécifique, $L_p$-norm, est appliqué aux différentes régions (voir fig.6). Un tel opérateur ne donne qu'une seule valeur par région (1 valeur pour 4 pixels dans notre exemple). Nous itérons ensuite sur l'ensemble des données région par région, en prenant des mesures basées sur le pas. Si nous commençons avec $m * n$ données avec $c$ canaux, nous finirons avec $\frac{m}{2} * \frac{n}{2}$ données toujours avec des canaux $c$ (voir Fig.7). +Un opérateur spécifique, $L_p$-norm, est appliqué aux différentes régions (voir figure 6). Un tel opérateur ne donne qu'une seule valeur par région (1 valeur pour 4 pixels dans notre exemple). Nous itérons ensuite sur l'ensemble des données région par région, en prenant des mesures basées sur le pas. Si nous commençons avec $m \times n$ données avec $c$ canaux, nous finirons avec $\frac{m}{2} \times \frac{n}{2}$ données toujours avec des canaux $c$ (voir figure 7). Le pooling n'est pas paramétré ; néanmoins, nous pouvons choisir différents types comme le max-pooling maximum, le average-pooling, etc. Le but principal du pooling est de réduire la quantité de données afin que nous puissions faire les calculs dans un délai raisonnable.

@@ -239,9 +239,9 @@ The performance of the FC network almost stayed unchanged ($85\%$), but the accu --> ## ConvNet - Notebook Jupyter -Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/06-convnet.ipynb). Pour faire fonctionner le notebook, assurez-vous d'avoir installé l'environnement `pDL` comme indiqué dans [`README.md`](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/README.md). +La version anglaise du *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/06-convnet.ipynb). La version en français est disponible [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/06-convnet.ipynb). Pour faire fonctionner le *notebook*, assurez-vous d'avoir installé l'environnement `pDL` comme indiqué dans le fichier [`README.md`](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/docs/fr/README-FR.md). -Dans ce notebook Jupyter, nous entraînons un perceptron multicouche (réseau FC) et un ConvNet pour la tâche de classification sur le jeu de données MNIST. Notez que les deux réseaux ont un nombre égal de paramètres. (Fig.8) +Dans ce *notebook* Jupyter, nous entraînons un perceptron multicouche (réseau FC) et un ConvNet pour la tâche de classification sur le jeu de données MNIST. Notez que les deux réseaux ont un nombre égal de paramètres (figure 8).

Figure 8: Instances provenant du jeu de données MNIST
@@ -254,7 +254,7 @@ Avant l’entraînement, nous normalisons nos données afin que l'initialisation Tout d'abord, nous entraînons les deux réseaux aux données normalisées du MNIST. La précision du réseau FC s'est avérée être de 87 %, tandis que celle du réseau ConvNet s'est révélée être de 95 %. Avec le même nombre de paramètres, le ConvNet a réussi à entraîner beaucoup plus de filtres. Dans le réseau FC, les filtres qui essaient d'obtenir des dépendances entre des choses qui sont plus éloignées et des choses qui sont proches, sont entraînés. Ils sont complètement gaspillés. Au lieu de cela, dans le réseau convolutionnel, tous ces paramètres se concentrent sur la relation entre les pixels voisins. -Ensuite, nous effectuons une permutation aléatoire de tous les pixels dans toutes les images de notre ensemble de données MNIST. Cela transforme notre Fig.8 en Fig.9. Nous entraînons ensuite les deux réseaux sur cet ensemble de données modifié. +Ensuite, nous effectuons une permutation aléatoire de tous les pixels dans toutes les images de notre ensemble de données MNIST. Cela transforme notre figure 8 en figure 9. Nous entraînons ensuite les deux réseaux sur cet ensemble de données modifié.

Figure 9: Instances provenant du jeu de données MNIST permuté
diff --git a/docs/fr/week03/03.md b/docs/fr/week03/03.md index f472bd313..34eed753d 100644 --- a/docs/fr/week03/03.md +++ b/docs/fr/week03/03.md @@ -13,7 +13,7 @@ We first see a visualization of a 6-layer neural network. Next we begin with the --> -## Conférence partie A +## Cours magistral partie A Nous voyons d'abord une visualisation d'un réseau de neurones à 6 couches. Ensuite, nous commençons par le sujet des convolutions et des réseaux neuronaux à convolution (ConvNets). Nous passons en revue plusieurs types de transformations de paramètres dans le contexte des ConvNets et introduisons l'idée d'un noyau, qui est utilisé pour apprendre des caractéristiques de manière hiérarchique. Cela nous permet de classer nos données d'entrée, ce qui est l'idée de base motivant l'utilisation des ConvNets. @@ -23,7 +23,7 @@ Nous voyons d'abord une visualisation d'un réseau de neurones à 6 couches. Ens We give an introduction on how CNNs have evolved over time. We discuss in detail different CNN architectures, including a modern implementation of LeNet5 to exemplify the task of digit recognition on the MNIST dataset. Based on its design principles, we expand on the advantages of CNNs which allows us to exploit the compositionality, stationarity, and locality features of natural images. --> -## Conférence partie B +## Cours magistral partie B Nous présentons une introduction sur l'évolution des ConvNets au fil du temps. Nous discutons en détail des différentes architectures de ConvNets, y compris une mise en œuvre moderne de LeNet5 pour illustrer la tâche de reconnaissance numérique sur le jeu de données du MNIST. Sur la base de ses principes de conception, nous développons les avantages des ConvNets qui nous permettent d'exploiter les caractéristiques de composition, de stationnarité et de localisation des images naturelles. @@ -33,6 +33,6 @@ Nous présentons une introduction sur l'évolution des ConvNets au fil du temps. Properties of natural signals that are most relevant to CNNs are discussed in more detail, namely: Locality, Stationarity, and Compositionality. We explore precisely how a kernel exploits these features through sparsity, weight sharing and the stacking of layers, as well as motivate the concepts of padding and pooling. Finally, a performance comparison between FCN and CNN was done for different data modalities. --> -## Pratique -Les propriétés des signaux naturels qui sont les plus pertinentes pour les ConvNets sont discutées plus en détail, à savoir : localité, stationnarité et compositionnalité. Nous explorons précisément comment un noyau exploite ces caractéristiques par l'éparsité (sparsity), le partage des poids (weight sharing) et l'empilement des couches (the stacking of layers) et abordons les concepts de rembourrage (padding) et de pooling. Enfin, une comparaison des performances entre FCN (fully connected network) et ConvNets est effectuée pour différents types de données. +## Travaux dirigés +Les propriétés des signaux naturels qui sont les plus pertinentes pour les ConvNets sont discutées plus en détail, à savoir : localité, stationnarité et compositionnalité. Nous explorons précisément comment un noyau exploite ces caractéristiques par l'éparsité, le partage des poids et l'empilement des couches et abordons les concepts de rembourrage et de pooling. Enfin, une comparaison des performances entre les réseaux entièrement conenctés (FCN pour *fully connected network*) et les ConvNets est effectuée pour différents types de données. diff --git a/docs/fr/week04/04-1.md b/docs/fr/week04/04-1.md index acaf2e734..f105adc6e 100644 --- a/docs/fr/week04/04-1.md +++ b/docs/fr/week04/04-1.md @@ -251,7 +251,7 @@ $$ Dans cet exemple, la matrice de poids a une taille de $4 \times 3$, le vecteur d'entrée a une taille de $3 \times 1$ et le vecteur de sortie a une taille de $4 \times 1$. -Cependant, pour les données audio, les données sont beaucoup plus longues (pas de 3 échantillons). Le nombre d'échantillons dans les données audio est égal à la durée de l'audio (par exemple 3 secondes) multipliée par le taux d'échantillonnage (par exemple 22,05 kHz). Comme indiqué ci-dessous, le vecteur d'entrée $\boldsymbol{x}$ sera assez long. En conséquence, la matrice de poids deviendra "grosse". +Cependant, pour les données audio, les données sont beaucoup plus longues (pas de 3 échantillons). Le nombre d'échantillons dans les données audio est égal à la durée de l'audio (par exemple 3 secondes) multipliée par le taux d'échantillonnage (par exemple 22,05 kHz). Comme indiqué ci-dessous, le vecteur d'entrée $\boldsymbol{x}$ sera assez long. En conséquence, la matrice de poids deviendra « grosse ». $$ @@ -490,11 +490,11 @@ Convolution of the input signal with all the pitches (all the keys of the piano
--> -## [Écouter les convolutions - Jupyter Notebook](https://www.youtube.com/watch?v=OrBEon3VlQg&t=1709s) +## [Écouter les convolutions - Notebook Jupyter](https://www.youtube.com/watch?v=OrBEon3VlQg&t=1709s) -Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/07-listening_to_kernels.ipynb). +La version anglaise du *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/07-listening_to_kernels.ipynb), la version française est disponible [là](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/07-listening_to_kernels.ipynb). -Dans ce notebook, nous allons explorer la convolution en tant que "produit scalaire courant". +Dans ce *notebook*, nous allons explorer la convolution en tant que "produit scalaire courant". La bibliothèque `librosa` nous permet de charger le clip audio $\boldsymbol{x}$ et son taux d'échantillonnage. Dans ce cas, il y a 70641 échantillons, le taux d'échantillonnage est de 22.05kHz et la durée totale du clip est de 3.2s. Le signal audio importé est ondulé (voir la figure 1) et nous pouvons deviner à quoi il ressemble d'après l'amplitude de l'axe $y$. Le signal audio $x(t)$ est en fait le son joué lorsque le système Windows est éteint (voir la figure 2). @@ -505,7 +505,7 @@ La bibliothèque `librosa` nous permet de charger le clip audio $\boldsymbol{x}$

-Fig. 2 : Notes pour le signal audio ci-dessus.
+Figure 2 : Notes pour le signal audio ci-dessus
@@ -513,7 +513,7 @@ Nous devons séparer les notes de la forme de l'onde. Pour y parvenir, si nous u

-Figure 3 : Signal audio et son spectrogramme.
+Figure 3 : Signal audio et son spectrogramme
La convolution du signal d'entrée avec toutes les hauteurs (toutes les touches du piano par exemple) peut aider à extraire toutes les notes du morceau d'entrée (c'est-à-dire les coups lorsque l'audio correspond aux noyaux spécifiques). Les spectrogrammes du signal original et du signal des hauteurs concaténées sont illustrés à la figure 4, tandis que les fréquences du signal original et des quatre hauteurs sont illustrées à la figure 5. Le tracé des convolutions des quatre noyaux avec le signal d'entrée (signal original) est illustré à la figure 6. La figure 6 ainsi que les clips audio des convolutions prouvent l'efficacité des convolutions dans l'extraction des notes. @@ -521,17 +521,17 @@ La convolution du signal d'entrée avec toutes les hauteurs (toutes les touches

-Fig. 4 : Spectrogramme du signal original (à gauche) et Sepctrogramme de la concaténation des hauteurs (à droite).
+Figure 4 : Spectrogramme du signal original (à gauche) et Sepctrogramme de la concaténation des hauteurs (à droite)

-Fig. 5 : Première note de la mélodie.
+Figure 5 : Première note de la mélodie

-Fig. 6 : Convolution de quatre noyaux.
+Figure 6 : Convolution de quatre noyaux
### Exemples -* Données audio : le domaine est 1-D, signal discret indexé par le temps ; le nombre de canaux $c$ peut varier entre 1 (mono), 2 (stéréo), 5+1 (Dolby 5.1), *etc.* -* Données d'image : le domaine est 2-D (pixels) ; $c$ peut varier entre 1(niveaux de gris), 3(couleur), 20(hyperspectral), *etc.* -* Relativité spéciale : le domaine est $\mathbb{R^4} \times \mathbb{R^4}$ (espace-temps $\times$ quatre-momentum) ; quand $c = 1$ on dit Hamiltonien. +* Données audio : le domaine est 1D, signal discret indexé par le temps. Le nombre de canaux $c$ peut varier entre 1 (mono), 2 (stéréo), 5+1 (Dolby 5.1), *etc.* +* Données d'image : le domaine est 2D (pixels) et le $c$ peut varier entre 1(niveaux de gris), 3(couleur), 20(hyperspectral), *etc.* +* Relativité spéciale : le domaine est $\mathbb{R^4} \times \mathbb{R^4}$ (espace-temps $\times$ quatre-momentum). Quand $c = 1$ on dit Hamiltonien.

-Fig. 7 : Différentes dimensions de différents types de signaux.
+Figure 7 : Différentes dimensions de différents types de signaux
diff --git a/docs/fr/week04/04.md b/docs/fr/week04/04.md index 0dc7d2e48..16d3ad3e8 100644 --- a/docs/fr/week04/04.md +++ b/docs/fr/week04/04.md @@ -12,7 +12,7 @@ translator: Loïck Bourdois We start with a brief review of linear algebra and then extend the topic to convolutions using audio data as an example. Key concepts like locality, stationarity and Toeplitz matrix are reiterated. Then we give a live demo of convolution performance in pitch analysis. Finally, there is a short digression about the dimensionality of different data. --> -Pratique +## Travaux dirigés Nous commençons par un bref examen de l'algèbre linéaire, puis nous étendons le sujet aux convolutions en utilisant des données audio comme exemple. Des concepts clés comme la localité, la stationnarité et la matrice de Toeplitz sont rappelés. Ensuite, nous donnons une démonstration en direct des performances des convolutions dans l'analyse de la hauteur de son. Enfin, une courte digression sur la dimensionnalité des différentes données. diff --git a/docs/fr/week05/05-1.md b/docs/fr/week05/05-1.md index dbb98b621..f03c47c57 100644 --- a/docs/fr/week05/05-1.md +++ b/docs/fr/week05/05-1.md @@ -48,13 +48,13 @@ The $\gamma$ parameter in the iterative update equation is called the **step siz Nous commençons notre étude des méthodes d'optimisation par la méthode la plus élémentaire et la pire (raisonnement à suivre) du lot : la méthode de la descente de gradient. -**Problème:** +**Problème :** $$ \min_w f(w) $$ -**Solution itérative:** +**Solution itérative :** $$ w_{k+1} = w_k - \gamma_k \nabla f(w_k) @@ -67,14 +67,14 @@ où, - $\nabla f(w_k)$ est le gradient de $f$. -On suppose ici que la fonction $f$ est continue et différenciable. Notre objectif est de trouver le point le plus bas (vallée) de la fonction d'optimisation. Cependant, la direction réelle de cette vallée n'est pas connue. Nous ne pouvons regarder que localement, et donc la direction du gradient négatif est la meilleure information dont nous disposons. Faire un petit pas dans cette direction ne peut que nous rapprocher du minimum. Une fois que nous avons fait ce petit pas, nous calculons à nouveau le nouveau gradient et nous nous déplaçons à nouveau un peu dans cette direction, jusqu'à ce que nous atteignions la vallée. Par conséquent, la descente de de gradient ne fait essentiellement que suivre la direction de la descente la plus raide (pente négative). +On suppose ici que la fonction $f$ est continue et différenciable. Notre objectif est de trouver le point le plus bas (vallée) de la fonction d'optimisation. Cependant, la direction réelle de cette vallée n'est pas connue. Nous ne pouvons regarder que localement et de ce fait la direction du gradient négatif est la meilleure information dont nous disposons. Faire un petit pas dans cette direction ne peut que nous rapprocher du minimum. Une fois que nous avons fait ce petit pas, nous calculons à nouveau le nouveau gradient et nous nous déplaçons à nouveau un peu dans cette direction, jusqu'à ce que nous atteignions la vallée. Par conséquent, la descente de de gradient ne fait essentiellement que suivre la direction de la descente la plus raide (pente négative). -Le paramètre $\gamma$ dans l'équation de mise à jour itérative est appelé la **taille du pas**. En général, nous ne connaissons pas la valeur de la taille de pas optimale ; nous devons donc essayer différentes valeurs. La pratique courante consiste à essayer un ensemble de valeurs sur une échelle logarithmique et à utiliser ensuite la meilleure. Quelques scénarios différents peuvent se produire. L'image ci-dessus représente ces scénarios pour une fonction quadratique 1D. Si le taux d'apprentissage est trop faible, alors nous progresserons régulièrement vers le minimum. Cependant, cela pourrait prendre plus de temps que ce qui est idéal. Il est généralement très difficile (ou impossible) d'obtenir une échelle qui nous mènerait directement au minimum. L'idéal serait d'avoir une taille de pas un peu plus grande que l'optimale. En pratique, cela permet d'obtenir la convergence la plus rapide. Cependant, si nous utilisons un taux d'apprentissage trop élevé, les itérations s'éloignent de plus en plus des minima et nous obtenons une divergence. Dans la pratique, nous voudrions utiliser un taux d'apprentissage qui est juste un peu moins que divergent. +Le paramètre $\gamma$ dans l'équation de mise à jour itérative est appelé la **taille du pas**. En général, nous ne connaissons pas la valeur de la taille de pas optimale. Nous devons donc essayer différentes valeurs. La pratique courante consiste à essayer un ensemble de valeurs sur une échelle logarithmique et à utiliser ensuite la meilleure. Quelques scénarios différents peuvent se produire. L'image ci-dessus représente ces scénarios pour une fonction quadratique 1D. Si le taux d'apprentissage est trop faible, alors nous progresserons régulièrement vers le minimum. Cependant, cela pourrait prendre plus de temps que ce qui est idéal. Il est généralement très difficile (ou impossible) d'obtenir une échelle qui nous mènerait directement au minimum. L'idéal serait d'avoir une taille de pas un peu plus grande que l'optimale. En pratique, cela permet d'obtenir la convergence la plus rapide. Cependant, si nous utilisons un taux d'apprentissage trop élevé, les itérations s'éloignent de plus en plus des minima et nous obtenons une divergence. Dans la pratique, nous voudrions utiliser un taux d'apprentissage qui est juste un peu moins que divergent.

-Figure 1: Différentes valeurs du pas appliquer à une fonction quadratique 1D +Figure 1 : Différentes valeurs du pas appliquer à une fonction quadratique 1D
@@ -167,11 +167,11 @@ $$ \mathbb{E}[w_{k+1}] = w_k - \gamma_k \mathbb{E}[\nabla f_i(w_k)] = w_k - \gamma_k \nabla f(w_k) $$ -Ainsi, toute mise à jour de la SGD est la même que la mise à jour complète attendue. Cependant, la SGD n'est pas seulement une descente plus rapide avec du bruit. En plus d'être plus rapide, la SGD peut également nous donner de meilleurs résultats que la descente de gradient en batch complet. Le bruit dans la SGD peut nous aider à éviter les minima locaux peu profonds et à trouver de meilleurs minima (plus profonds). Ce phénomène est appelé **annealing**. +Ainsi, toute mise à jour de la SGD est la même que la mise à jour complète attendue. Cependant, la SGD n'est pas seulement une descente plus rapide avec du bruit. En plus d'être plus rapide, la SGD peut également nous donner de meilleurs résultats que la descente de gradient en batch complet. Le bruit dans la SGD peut nous aider à éviter les minima locaux peu profonds et à trouver de meilleurs minima (plus profonds). Ce phénomène est appelé ***annealing***.

-Figure 2: Annealing avec SGD +Figure 2 : Annealing avec SGD
En résumé, les avantages de la descente de gradient stochastique sont les suivants : @@ -204,8 +204,7 @@ $$ w_{k+1} = w_k - \gamma_k \frac{1}{|B_i|} \sum_{j \in B_i}\nabla f_j(w_k) $$ -Souvent, nous pouvons faire un meilleur usage de nos capacités de calcul en utilisant des mini batch au lieu d'une seule instance. Par exemple, les GPU sont mal utilisés lorsque nous effectuons un entraînement avec une seule instance. Les techniques d’entraînement en réseau distribué répartissent les mini batchs entre les différentes machines et agrègent ensuite les gradients résultants. Facebook a récemment entraîné un réseau sur les données d'ImageNet en moins d'une heure, en utilisant une telle distribution. - +Souvent, nous pouvons faire un meilleur usage de nos capacités de calcul en utilisant des mini batch au lieu d'une seule instance. Par exemple, les GPU sont mal utilisés lorsque nous effectuons un entraînement avec une seule instance. Les techniques d’entraînement en réseau distribué répartissent les mini batchs entre les différentes machines et agrègent ensuite les gradients résultants. En utilisant une telle distribution, Facebook a récemment entraîné un réseau sur les données d'ImageNet en moins d'une heure ([Goyal et al. (2018)](https://arxiv.org/abs/1706.02677v2)). Il est important de noter que la descente de gradient ne doit jamais être utilisée avec des batchs entier (taille entière). Si vous souhaitez faire cela utilisez plutôt une technique d'optimisation appelée LBFGS. PyTorch et SciPy fournissent tous deux des implémentations de cette technique. @@ -236,7 +235,7 @@ This form is mathematically equivalent to the previous form. Here, the next step ## [Momentum](https://www.youtube.com/watch?v=--NZb480zlg&t=1672s) -Avec Momentum, nous avons deux itérations ($p$ et $w$) au lieu d'une seule. Les mises à jour sont les suivantes : +Avec *momentum*, nous avons deux itérations ($p$ et $w$) au lieu d'une seule. Les mises à jour sont les suivantes : $$ \begin{aligned} @@ -245,9 +244,9 @@ w_{k+1} &= w_k - \gamma_kp_{k+1} \\ \end{aligned} $$ -$p$ est appelé le momentum du SGD. À chaque étape de la mise à jour, nous ajoutons le gradient stochastique à l'ancienne valeur du momentum, après l'avoir amorti d'un facteur $\beta$ (valeur comprise entre 0 et 1). On peut considérer $p$ comme une moyenne mobile des gradients. Enfin, nous déplaçons $w$ dans la direction du nouvel élan $p$. +$p$ est appelé le *momentum* da la SGD. À chaque étape de la mise à jour, nous ajoutons le gradient stochastique à l'ancienne valeur du *momentum*, après l'avoir amorti d'un facteur $\beta$ (valeur comprise entre 0 et 1). On peut considérer $p$ comme une moyenne mobile des gradients. Enfin, nous déplaçons $w$ dans la direction du nouvel élan $p$. -Forme alternative : Méthode stochastique de la boule lourde +Forme alternative : « méthode stochastique de la boule lourde » $$ \begin{aligned} @@ -281,21 +280,21 @@ The $\beta$ parameter is called the Dampening Factor. $\beta$ has to be greater ### Intuition -Le SGD Momentum est similaire au concept d'élan en physique. Le processus d'optimisation ressemble à une lourde balle qui dévale la colline. Momentum maintient la balle dans la même direction que celle dans laquelle elle se déplace déjà. Le gradient peut être considéré comme une force poussant la balle dans une autre direction. +La SGD *momentum* est similaire au concept d'élan en physique. Le processus d'optimisation ressemble à une lourde balle qui dévale la colline. *Momentum* maintient la balle dans la même direction que celle dans laquelle elle se déplace déjà. Le gradient peut être considéré comme une force poussant la balle dans une autre direction.

-Figure 3: Effet du Momentum
-Source:
distill.pub
+Figure 3 : Effet du momentum - +Source : distill.pub
-Plutôt que de changer radicalement la direction du voyage (comme dans la figure de gauche), le momentum apporte des changements modestes. Il amortit les oscillations qui sont courantes lorsque nous n'utilisons que la SGD. +Plutôt que de changer radicalement la direction du voyage (comme dans la figure de gauche), le *momentum* apporte des changements modestes. Il amortit les oscillations qui sont courantes lorsque nous n'utilisons que la SGD. Le paramètre $\beta$ est appelé le facteur d'amortissement. $\beta$ doit être supérieur à zéro, car s'il est égal à zéro, vous ne faites que descendre une pente. Il doit également être inférieur à 1, sinon tout explosera. Des valeurs plus petites de $\beta$ entraînent un changement de direction plus rapide. Pour des valeurs plus élevées, il faut plus de temps pour faire des virages.

-Figure 4: Effet du bêta sur la convergence +Figure 4 : Effet du bêta sur la convergence
@@ -310,17 +309,17 @@ The step size parameter usually needs to be decreased when the momentum paramete ### Informations pratiques -Le momentum doit presque toujours être utilisé avec une descente de gradient stochastique. +Le *momentum* doit presque toujours être utilisé avec une descente de gradient stochastique. $\beta$ = 0,9 ou 0,99 fonctionne presque toujours bien. -La valeur du pas doit généralement être diminuée lorsque le paramètre de momentum est augmenté pour maintenir la convergence. Si $\beta$ passe de 0,9 à 0,99, le taux d'apprentissage doit être diminué d'un facteur 10. +La valeur du pas doit généralement être diminuée lorsque le paramètre de *momentum* est augmenté pour maintenir la convergence. Si $\beta$ passe de 0,9 à 0,99, le taux d'apprentissage doit être diminué d'un facteur 10. -### Comment fonctionne le momentum ? +### Comment fonctionne le *momentum* ? #### Lissage du bruit -Une raison plus pratique et plus probable pour laquelle le momentum fonctionne est probablement le lissage du bruit. -Le momentum est une moyenne mobile des gradients que nous utilisons pour chaque étape de mise à jour. +Une raison plus pratique et plus probable pour laquelle le *momentum* fonctionne est probablement le lissage du bruit. +Le *momentum* est une moyenne mobile des gradients que nous utilisons pour chaque étape de mise à jour. Théoriquement, pour que la SGD fonctionne, nous devrions prendre la moyenne de toutes les mises à jour par étapes. $$ \bar w_k = \frac{1}{K} \sum_{k=1}^K w_k $$ -L'avantage avec la SGD avec momentum est que cette moyenne n'est plus nécessaire. Le momentum ajoute un lissage au processus d'optimisation, ce qui fait de chaque mise à jour une bonne approximation de la solution. Avec SGD, vous voudriez faire la moyenne de tout un tas de mises à jour et ensuite faire un pas dans cette direction. -L'accélération et le lissage du bruit contribuent tous deux à la performance élevée du momentum. +L'avantage avec la SGD avec *momentum* est que cette moyenne n'est plus nécessaire. Le *momentum* ajoute un lissage au processus d'optimisation, ce qui fait de chaque mise à jour une bonne approximation de la solution. Avec la SGD, vous voudriez faire la moyenne de tout un tas de mises à jour et ensuite faire un pas dans cette direction. +L'accélération et le lissage du bruit contribuent tous deux à la performance élevée du *momentum*.

-Figure 5: SGD vs. Momentum +Figure 5 : SGD vs. Momentum
Avec la SGD, nous progressons bien vers une solution au départ, mais lorsque nous atteignons le fond de la vallée, nous rebondissons dans ce sol. Si nous ajustons le taux d'apprentissage, nous rebondirons plus lentement. Avec l'élan, nous lissons les étapes, de sorte qu'il n'y a pas de rebondissement. diff --git a/docs/fr/week05/05-2.md b/docs/fr/week05/05-2.md index d47f9ae3b..2fb11795b 100644 --- a/docs/fr/week05/05-2.md +++ b/docs/fr/week05/05-2.md @@ -28,7 +28,7 @@ Weights in the latter part of the network (4096 in figure 1 below) directly dict ## [Méthodes adaptatives](https://www.youtube.com/watch?v=--NZb480zlg&t=2675s) -SGD avec momentum est actuellement la méthode d'optimisation de pointe pour de nombreux problèmes de ML. Mais il existe d'autres méthodes, généralement appelées méthodes adaptatives qui sont particulièrement utiles pour les problèmes mal conditionnés (si la SGD ne fonctionne pas). +La SGD avec *momentum* est actuellement la méthode d'optimisation de pointe pour de nombreux problèmes de ML. Mais il existe d'autres méthodes, généralement appelées méthodes adaptatives qui sont particulièrement utiles pour les problèmes mal conditionnés (si la SGD ne fonctionne pas). Dans la formule de la SGD, chaque poids dans le réseau est mis à jour en utilisant une équation avec le même taux d'apprentissage (global $\gamma$). Ici, pour les méthodes adaptatives, nous *adaptons un taux d'apprentissage pour chaque poids individuellement*. À cette fin, nous utilisons les informations que nous obtenons des gradients pour chaque poids. @@ -38,7 +38,7 @@ Les poids dans la dernière partie du réseau (4096 dans la figure 1 ci-dessous)

-Figure 1: VGG16 +Figure 1 : VGG16
@@ -85,7 +85,7 @@ Nous mettons à jour $v$ pour estimer cette quantité bruyante via une *moyenne La méthode originale conserve une moyenne mobile exponentielle d'un second moment non central, donc nous ne soustrayons pas la moyenne ici. Le *deuxième moment* est utilisé pour normaliser par élément le gradient, ce qui signifie que chaque élément du gradient est divisé par la racine carrée de l'estimation du deuxième moment. Si la valeur attendue du gradient est faible, ce processus est similaire à la division du gradient par l'écart-type. -L'utilisation d'un petit $\epsilon$ au dénominateur ne diverge pas car lorsque $v$ est très petit, le momentum est également très petit. +L'utilisation d'un petit $\epsilon$ au dénominateur ne diverge pas car lorsque $v$ est très petit, le *momentum* est également très petit. ## Plus de choses : des gradients personnalisés -Au lieu d'opérations numériques de base, nous pouvons générer nos propres modules / fonctions auto-définis, qui peuvent être branchés sur le graphe neural. Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/extra/b-custom_grads.ipynb). +Au lieu d'opérations numériques de base, nous pouvons générer nos propres modules / fonctions auto-définis, qui peuvent être branchés sur le graphe neural. Le *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/extra/b-custom_grads.ipynb). Pour ce faire, nous devons partir de la fonction `torch.autograd.Function` et remplacer les fonctions `forward()` et `backward()`. Par exemple, si nous voulons entraîner des réseaux, nous devons obtenir la propagation en avant dans le réseau (forward) et connaître les dérivées partielles de l'entrée par rapport à la sortie, de sorte que nous puissions utiliser ce module en tout point du code. Ensuite, en utilisant la rétropropagation (règle de la chaîne), nous pouvons insérer la chose n'importe où dans la chaîne d'opérations, à condition de connaître les dérivées partielles de l'entrée par rapport à la sortie. Dans ce cas, il y a trois exemples de ***modules personnalisés*** dans le *notebook*, les modules `add`, `split`, et `max`. Par exemple, le module d'ajout personnalisé : ```python -# Custom addition module +# Module personnalisé supplémentaire class MyAdd(torch.autograd.Function): @staticmethod def forward(ctx, x1, x2): - # ctx is a context where we can save - # computations for backward. + # ctx est un contexte où nous pouvons sauvegarder les calculs pour la rétropropagation ctx.save_for_backward(x1, x2) return x1 + x2 @@ -441,11 +438,9 @@ class MyAdd(torch.autograd.Function): x1, x2 = ctx.saved_tensors grad_x1 = grad_output * torch.ones_like(x1) grad_x2 = grad_output * torch.ones_like(x2) - # need to return grads in order - # of inputs to forward (excluding ctx) + # on a besoin de retourner les gradients pour la phase avant return grad_x1, grad_x2 ``` Si nous avons l'addition de deux choses et que nous obtenons un résultat, nous devons écraser la fonction forward comme ceci. Et lorsque nous descendons pour faire la propagation arrière, les gradients sont copiés sur les deux côtés. Nous écrasons donc la fonction arrière en copiant. Pour les fonctions `split` et `max`, consultez le code pour la façon dont nous écrasons les fonctions forward et backward dans le *notebook*. Pour `argmax`, cela sélectionne l'indice de la chose la plus élevée. Ainsi l'indice de la plus élevée devrait être de $1$ et $0$ pour les autres. - diff --git a/docs/fr/week05/05.md b/docs/fr/week05/05.md index 98bc1b1d6..b0a180a9d 100644 --- a/docs/fr/week05/05.md +++ b/docs/fr/week05/05.md @@ -13,9 +13,9 @@ We begin by introducing Gradient Descent. We discuss the intuition and also talk --> -## Conférence partie A +## Cours magistral partie A -Nous commençons par introduire la méthode de descente de gradient (GD). Nous discutons de l'intuition et nous expliquons également comment la taille des pas joue un rôle important dans l'obtention de la solution. Nous passons ensuite à la SGD (GD stochastique) et à ses performances par rapport à la GD « Full Batch ». Enfin, nous parlons des mises à jour Momentum, en particulier des deux règles de mise à jour, de l'intuition derrière le momentum et de son effet sur la convergence. +Nous commençons par introduire la méthode de descente de gradient (GD). Nous discutons de l'intuition et nous expliquons également comment la taille des pas joue un rôle important dans l'obtention de la solution. Nous passons ensuite à la SGD (GD stochastique) et à ses performances par rapport à la GD « *Full Batch* ». Enfin, nous parlons des mises à jour *momentum*, en particulier des deux règles de mise à jour, de l'intuition derrière le momentum et de son effet sur la convergence. -## Conférence partie B +## Cours magistral partie B Nous discutons des méthodes adaptatives pour la SGD telles que RMSprop et ADAM. Nous parlons également des couches de normalisation et de leurs effets sur le processus d'entraînement des réseaux neuronaux. Enfin, nous discutons d'un exemple concret de réseaux de neurones utilisés dans l'industrie pour rendre les scanners IRM plus rapides et plus efficaces. @@ -34,6 +34,6 @@ Nous discutons des méthodes adaptatives pour la SGD telles que RMSprop et ADAM. We briefly review the matrix-multiplications and then discuss the convolutions. Key point is we use kernels by stacking and shifting. We first understand the 1D convolution by hand, and then use PyTorch to learn the dimension of kernels and output width in 1D and 2D convolutions examples. Furthermore, we use PyTorch to learn about how automatic gradient works and custom-grads. --> -## Pratique +## Travaux dirigés Nous passons brièvement en revue les multiplications matricielles et discutons ensuite des convolutions. Le point essentiel est que nous utilisons les noyaux en les empilant et en les déplaçant. Nous commençons par comprendre la convolution 1D à la main, puis nous utilisons PyTorch pour apprendre la dimension des noyaux et la largeur de sortie dans des exemples de convolutions 1D et 2D. De plus, nous utilisons PyTorch pour apprendre comment fonctionne le gradient automatique et les gradations personnalisées. diff --git a/docs/fr/week06/06-1.md b/docs/fr/week06/06-1.md index e0979856c..b7bc19e53 100644 --- a/docs/fr/week06/06-1.md +++ b/docs/fr/week06/06-1.md @@ -17,7 +17,7 @@ In the previous lecture, we demonstrated that a convolutional network can recogn ## [Reconnaissance des codes postaux](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=43s) -Dans la conférence précédente, nous avons démontré qu'un réseau convolutif peut reconnaître des chiffres. Cependant, la question demeure de savoir comment le modèle choisit chaque chiffre et évite les perturbations sur les chiffres voisins. L'étape suivante consiste à détecter les objets qui ne se chevauchent pas et à utiliser l'approche générale de la suppression non maximale (NMS en anglais pour Non-Maximum Suppression). Etant donné l'hypothèse que l'entrée est une série de chiffres non chevauchants, la stratégie consiste à entraîner plusieurs réseaux convolutifs et à utiliser soit le vote majoritaire, soit à choisir les chiffres correspondant au score le plus élevé généré par le réseau convolutif. +Dans la conférence précédente, nous avons démontré qu'un réseau convolutif peut reconnaître des chiffres. Cependant, la question demeure de savoir comment le modèle choisit chaque chiffre et évite les perturbations sur les chiffres voisins. L'étape suivante consiste à détecter les objets qui ne se chevauchent pas et à utiliser l'approche générale de la suppression non maximale (NMS en anglais pour *Non-Maximum Suppression*). Etant donné l'hypothèse que l'entrée est une série de chiffres non chevauchants, la stratégie consiste à entraîner plusieurs réseaux convolutifs et à utiliser soit le vote majoritaire, soit à choisir les chiffres correspondant au score le plus élevé généré par le réseau convolutif. -### Negative mining +### *Negative mining* Dans la dernière section, nous avons vu comment le modèle se heurtera à un grand nombre de faux positifs au moment du test, car les objets peuvent ressembler à un visage de nombreuses façons. Aucun ensemble d’entraînement ne comprendra tous les objets qui ne sont pas des visages et qui ressemblent à des visages. Nous pouvons atténuer ce problème grâce au negative mining. Nous créons un ensemble de données négatives de taches non faciales que le modèle détecte comme des visages. Les données sont collectées en exécutant le modèle sur des entrées dont on sait qu'elles ne contiennent pas de visages. Ensuite, nous recyclons le détecteur en utilisant l'ensemble de données négatives. Nous pouvons répéter ce processus pour augmenter la robustesse de notre modèle contre les faux positifs. @@ -169,43 +169,43 @@ When trying to get to a GPS coordinate on the other side of a barrier, the robot Back in the 2000s, computation resources were restricted. The robot was able to process around 1 frame per second, which means it would not be able to detect a person that walks in its way for a whole second before being able to react. The solution for this limitation is a **Low-Cost Visual Odometry** model. It is not based on neural networks, has a vision of ~2.5m but reacts quickly. --> -### [ConvNets pour la vision robotique adaptative à longue portée](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=1669s) +### [ConvNets pour la vision adaptative à longue portée de robots](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=1669s) Dans ce projet, l'objectif était d'étiqueter des régions à partir d'images d'entrée afin qu'un robot puisse distinguer les routes des obstacles. Dans la figure, les régions vertes sont les zones sur lesquelles le robot peut rouler et les régions rouges sont les obstacles comme les herbes hautes. Pour entraîner le réseau à cette tâche, nous avons pris un patch de l'image et l'avons étiqueté manuellement comme étant traversable ou non (vert ou rouge). Nous entraînons ensuite le réseau convolutif sur les patchs en lui demandant de prédire la couleur du patch. Une fois que le système est suffisamment entraîné, il est appliqué à l'ensemble de l'image, en étiquetant toutes les régions de l'image en vert ou en rouge.
-
-Figure 4: CNN pour la vision robotique adaptative à longue portée (programme LAGR de la DARPA 2005-2008) +
+Figure 4 : ConvNets pour la vision adaptative à longue portée de robots (programme LAGR de la DARPA 2005-2008)
Il y avait cinq catégories pour les prévisions : 1) super vert, 2) vert, 3) violet, 4) obstacle rouge, 5) super rouge : un obstacle certain. -* **Étiquettes stéréo** (Figure 4, colonne 2) - Les images sont captées par les 4 caméras du robot, qui sont regroupées en 2 paires de vision stéréo. En utilisant les distances connues entre les caméras des paires stéréoscopiques, les positions de chaque pixel dans l'espace 3D sont ensuite estimées en mesurant les distances relatives entre les pixels qui apparaissent dans les deux caméras d'une paire stéréoscopique. C'est le même processus que notre cerveau utilise pour estimer la distance des objets que nous voyons. En utilisant les informations de position estimées, un plan est ajusté au sol, et les pixels sont alors étiquetés en vert s'ils sont proches du sol et en rouge s'ils sont au-dessus. +* **Étiquettes stéréo** (Figure 4, colonne 2) : +Les images sont captées par les 4 caméras du robot, qui sont regroupées en 2 paires de vision stéréo. En utilisant les distances connues entre les caméras des paires stéréoscopiques, les positions de chaque pixel dans l'espace 3D sont ensuite estimées en mesurant les distances relatives entre les pixels qui apparaissent dans les deux caméras d'une paire stéréoscopique. C'est le même processus que notre cerveau utilise pour estimer la distance des objets que nous voyons. En utilisant les informations de position estimées, un plan est ajusté au sol, et les pixels sont alors étiquetés en vert s'ils sont proches du sol et en rouge s'ils sont au-dessus. -* **Limitations & Motivation pour les ConvNets** : La vision stéréo ne fonctionne que jusqu'à 10 mètres et la conduite d'un robot nécessite une vision à longue distance. Un ConvNet est cependant capable de détecter des objets à des distances beaucoup plus grandes, s'il est correctement entraîné. +* **Limitations & Motivation pour les ConvNets** : +La vision stéréo ne fonctionne que jusqu'à 10 mètres et la conduite d'un robot nécessite une vision à longue distance. Un ConvNet est cependant capable de détecter des objets à des distances beaucoup plus grandes, s'il est correctement entraîné.

-Figure 5: Pyramide des images normalisées à distance, sans échelle +Figure 5 : Pyramide des images normalisées à distance, sans échelle
-* **Servie comme entrée modèle** : Un prétraitement important comprend la construction d'une pyramide d'images à distance normalisée et à échelle variable (figure 5). Elle est similaire à ce que nous avons fait plus tôt dans cette conférence lorsque nous avons essayé de détecter des visages à plusieurs échelles. - -* **Sorties du modèle** (Figure 4, colonne 3) - -Le modèle produit une étiquette pour chaque pixel de l'image **jusqu'à l'horizon**. Ce sont les sorties de classificateur d'un réseau convolutionnel multi-échelle. +* **Servie comme entrée modèle** : +Un prétraitement important comprend la construction d'une pyramide d'images à distance normalisée et à échelle variable (figure 5). Elle est similaire à ce que nous avons fait plus tôt dans cette conférence lorsque nous avons essayé de détecter des visages à plusieurs échelles. -* **Comment le modèle devient adaptatif** : Les robots ont un accès continu aux étiquettes stéréo, ce qui permet au réseau de se réentraîner et de s'adapter au nouvel environnement dans lequel il se trouve. Veuillez noter que seule la dernière couche du réseau sera entraînée à nouveau. Les couches précédentes sont formées entraînée en laboratoire et fixées. +* **Sorties du modèle** (Figure 4, colonne 3) : +Le modèle produit une étiquette pour chaque pixel de l'image **jusqu'à l'horizon**. Ce sont les sorties de classifieur d'un réseau convolutionnel multi-échelle. -* **Performances du système** +* **Comment le modèle devient adaptatif** : +Les robots ont un accès continu aux étiquettes stéréo, ce qui permet au réseau de se réentraîner et de s'adapter au nouvel environnement dans lequel il se trouve. Veuillez noter que seule la dernière couche du réseau sera entraînée à nouveau. Les couches précédentes sont formées entraînée en laboratoire et fixées. -En essayant d'obtenir une coordonnée GPS de l'autre côté d'une barrière, le robot a "vu" la barrière de loin et a planifié un itinéraire qui l'a évitée. Ceci grâce à la détection d'objets situés à une distance de 50 à 100 m. +* **Performances du système** : +En essayant d'obtenir une coordonnée GPS de l'autre côté d'une barrière, le robot a perçu la barrière de loin et a planifié un itinéraire qui l'a évitée. Ceci grâce à la détection d'objets situés à une distance de 50 à 100 m. -* **Limitation** - -Dans les années 2000, les ressources de calcul étaient limitées. Le robot était capable de traiter environ une image par seconde, ce qui signifie qu'il ne pouvait pas détecter une personne qui se trouvait sur son chemin pendant une seconde entière avant de pouvoir réagir. La solution à cette limitation est un modèle d'"odométrie visuelle à faible coût". Il n'est pas basé sur les réseaux de neurones, a une vision de ~2,5m mais réagit rapidement. +* **Limitation** : +Dans les années 2000, les ressources de calcul étaient limitées. Le robot était capable de traiter environ une image par seconde, ce qui signifie qu'il ne pouvait pas détecter une personne qui se trouvait sur son chemin pendant une seconde entière avant de pouvoir réagir. La solution à cette limitation est un modèle d'odométrie visuelle à faible coût. Il n'est pas basé sur les réseaux de neurones, a une vision de ~2,5m mais réagit rapidement. @@ -238,16 +238,19 @@ Now the largest effective size of content, which is from the 1/4 resized image, ### Analyse et étiquetage des scènes Dans cette tâche, le modèle produit une catégorie d'objets (bâtiments, voitures, ciel, etc.) pour chaque pixel. L'architecture est également multi-échelle (figure 6). +

-Figure 6: ConvNet multi-échelle pour l'analyse des scènes +Figure 6 : ConvNet multi-échelle pour l'analyse des scènes
+ Remarquez que si nous projetons en arrière une sortie du ConvNet sur l'entrée, cela correspond à une fenêtre d'entrée de taille $46 \times 46$ sur l'image originale au bas de la pyramide de Laplace. Cela signifie que nous **utilisons le contexte des pixels $46 \times 46$ pour décider de la catégorie du pixel central**. Cependant, parfois, la taille de ce contexte n'est pas suffisante pour déterminer la catégorie des objets plus grands. **L'approche multi-échelle permet une vision plus large en fournissant des images supplémentaires redimensionnées comme entrées** : 1. Prendre la même image, la réduire d'un facteur 2 et d'un facteur 4, séparément. 2. Ces deux images redimensionnées supplémentaires sont envoyées au **même ConvNet** (mêmes poids, mêmes noyaux) et nous obtenons deux autres ensembles de caractéristiques de niveau 2. 3. **Échantillonnez** ces caractéristiques de façon à ce qu'elles aient la même taille que les caractéristiques de niveau 2 de l'image originale. -4. **Empilez** les trois ensembles de caractéristiques (suréchantillonnées) et envoyez-les à un classificateur. +4. **Empilez** les trois ensembles de caractéristiques (suréchantillonnées) et envoyez-les à un classifieur. +5. Maintenant, la plus grande taille effective du contenu, qui provient de l'image redimensionnée à 1/4, est de $184\times 184 \(46\times 4=184)$. -**Performance** : Sans post-traitement et en fonctionnant image par image, le modèle fonctionne très rapidement, même sur du matériel standard. Il a une taille assez réduite de données d'entraînement (2k~3k), mais les résultats sont toujours très performants. +**Performance** : sans post-traitement et en fonctionnant image par image, le modèle fonctionne très rapidement, même sur du matériel standard. Il a une taille assez réduite de données d'entraînement (2k~3k), mais les résultats sont toujours très performants. diff --git a/docs/fr/week06/06-2.md b/docs/fr/week06/06-2.md index 957e59149..d0629e6da 100644 --- a/docs/fr/week06/06-2.md +++ b/docs/fr/week06/06-2.md @@ -46,7 +46,7 @@ Figure 1. Recurrent Neural Network with roll - $\text{Dec}(z(t))$: decoder that generates an output --> -## Réseaux récurrents (RNN) +## Réseaux récurrents (RNNs) Dans un réseau neuronal convolutif, le graphe ou les interconnexions entre les modules ne peuvent pas avoir de boucles. Il existe au moins un ordre partiel entre les modules, de sorte que les entrées sont disponibles lorsque nous calculons les sorties. @@ -54,7 +54,7 @@ Comme le montre la figure 1, il existe des boucles dans les réseaux neuronaux r

-Figure 1. Réseau neuronal récurrent enroulé +Figure 1 : Réseau neuronal récurrent enroulé
- $x(t)$ : entrée qui varie dans le temps @@ -63,7 +63,7 @@ Figure 1. Réseau neuronal récurrent enroulé - $w$ : paramètres pouvant être entraînés - $z(t-1)$ : état caché précédent, qui est la sortie du pas de temps précédent - $z(t)$ : état caché actuel - - $g$ : fonction qui peut être un réseau de neurones compliqué ; l'une des entrées est $z(t-1)$ qui est la sortie du pas de temps précédent + - $g$ : fonction qui peut être un réseau de neurones compliqué. L'une des entrées est $z(t-1)$ qui est la sortie du pas de temps précédent - $\text{Dec}(z(t))$ : décodeur qui génère une sortie @@ -112,27 +112,24 @@ Figure 2. Réseaux récurrents dépliés Dans la figure 2, l'entrée est $x_1, x_2, x_3$. -Au temps t=0, l'entrée $x(0)$ est passée à l’encodeur et celui-ci génère la représentation $h(x(0)) = \text{Enc}(x(0))$ puis la passe à G pour générer l'état caché $z(0) = G(h_0, z', w)$. À $t = 0$, $z'$ dans $G$ peut être initialisé comme $0$ ou initialisé de façon aléatoire. $z(0)$ est passé au décodeur pour générer une sortie et également au pas de temps suivant. +Au temps $t = 0$, l'entrée $x(0)$ est passée à l’encodeur et celui-ci génère la représentation $h(x(0)) = \text{Enc}(x(0))$ puis la passe à G pour générer l'état caché $z(0) = G(h_0, z', w)$. À $t = 0$, $z'$ dans $G$ peut être initialisé comme $0$ ou initialisé de façon aléatoire. $z(0)$ est passé au décodeur pour générer une sortie et également au pas de temps suivant. Comme il n'y a pas de boucles dans ce réseau nous pouvons mettre en œuvre la rétropropagation. La figure 2 montre un réseau avec une caractéristique particulière : chaque bloc partage les mêmes poids. Trois encodeurs, décodeurs et fonctions G ont respectivement les mêmes poids sur différents pas de temps. -Malheureusement, la BPTT (Rétropropagation à travers le temps) ne fonctionne pas aussi bien dans la forme naïve du RNN. - -Problèmes avec les RNN : +Malheureusement, la rétropropagation à travers le temps (BPTT pour *Backpropagation through time*) ne fonctionne pas aussi bien dans la forme naïve du RNN. +Problèmes avec les RNNs : 1. Disparition du gradient - Dans une longue séquence, les gradients sont multipliés par la matrice de poids (transposée) à chaque pas de temps. S'il y a de petites valeurs dans la matrice de poids, la norme des gradients devient de plus en plus petite de manière exponentielle. 2. Explosion du gradient - Si nous avons une grande matrice de poids et que la non-linéarité dans la couche récurrente n'est pas saturée, les gradients vont exploser. Les poids divergeront à l'étape de mise à jour. Il se peut que nous devions utiliser un taux d'apprentissage minuscule pour que la descente des gradients fonctionne. -L'une des raisons d'utiliser les RNN est l'avantage de se souvenir des informations du passé. Cependant, il pourrait ne pas mémoriser les informations d'il y a longtemps. - +L'une des raisons d'utiliser les RNNs est l'avantage de se souvenir des informations du passé. Cependant, il pourrait ne pas mémoriser les informations d'il y a longtemps. -Un exemple qui a le problème de la disparition des gradients : -L'entrée est constituée des caractères d'un programme en langage C. Le système indiquera s'il s'agit d'un programme syntaxiquement correct. Un programme syntaxiquement correct doit avoir un nombre valide d'accolades et de parenthèses. Ainsi, le réseau doit se souvenir du nombre de parenthèses et d'accolades ouvertes à vérifier, et si nous les avons toutes fermées. Le réseau doit stocker ces informations dans des états cachés comme un compteur. Cependant, en raison de la disparition des gradients, il ne parviendra pas à conserver ces informations dans un programme long. +Un exemple du problème de la disparition des gradients. Considérons une entrée constituée des caractères d'un programme en langage C. Le système indiquera s'il s'agit d'un programme syntaxiquement correct. Un programme syntaxiquement correct doit avoir un nombre valide d'accolades et de parenthèses. Ainsi, le réseau doit se souvenir du nombre de parenthèses et d'accolades ouvertes à vérifier, et si nous les avons toutes fermées. Le réseau doit stocker ces informations dans des états cachés comme un compteur. Cependant, en raison de la disparition des gradients, il ne parviendra pas à conserver ces informations dans un programme long. -## Astuces pour les RNN +## Astuces pour les RNNs -- couper les gradients : (éviter l’explosion) +- couper les gradients pour éviter l’explosion : Écrasez les gradients lorsqu'ils deviennent trop importants. -- Initialisation (commencer à droite évite l'explosion/la disparition) +- jouer sur l'initialisation (commencer à droite évite l'explosion/la disparition) : Initialiser les matrices de poids pour préserver la norme dans une certaine mesure. Par exemple, l'initialisation orthogonale initialise la matrice de poids comme une matrice orthogonale aléatoire. -## [Gated Recurrent Units (GRU)](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=3549s) +## Les [Gated Recurrent Units (GRUs)](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=3549s) -Comme mentionné ci-dessus, le RNN souffre de la disparition/explosion des gradients et ne se souvient pas des états pendant très longtemps. Les GRU, [Cho, 2014](https://arxiv.org/abs/1406.1078), sont une application de modules multiplicatifs qui tente de résoudre ces problèmes. C'est un exemple de réseau récurrent avec mémoire (un autre est LSTM). La structure d'une unité GRU est présentée ci-dessous : +Comme mentionné ci-dessus, le RNN souffre de la disparition/explosion des gradients et ne se souvient pas des états pendant très longtemps. Les GRUS, [Cho et al. (2014)](https://arxiv.org/abs/1406.1078), sont une application de modules multiplicatifs qui tente de résoudre ces problèmes. C'est un exemple de réseau récurrent avec mémoire. La structure d'une unité GRU est présentée ci-dessous :

-Figure 3. Gated Recurrent Unit +Figure 3 : Gated Recurrent Unit
$$ @@ -320,7 +317,7 @@ h_t = z_t\odot h_{t-1} + (1- z_t)\odot\phi_h(W_hx_t + U_h(r_t\odot h_{t-1}) + b_ \end{array} $$ -où $\odot$ indique une multiplication par élément (produit Hadamard), $x_t$ est le vecteur d'entrée, $h_t$ est le vecteur de sortie, $z_t$ est le vecteur de mise à jour, $r_t$ est le vecteur de réinitialisation, $\phi_h$ est un tanh hyperbolique, et $W$,$U$,$b$ sont des paramètres pouvant être appris. +où $\odot$ indique une multiplication par élément (produit Hadamard), $x_t$ est le vecteur d'entrée, $h_t$ est le vecteur de sortie, $z_t$ est le vecteur de mise à jour, $r_t$ est le vecteur de réinitialisation, $\phi_h$ est une tanh, et $W$,$U$,$b$ sont des paramètres pouvant être appris. Pour être précis, $z_t$ est un vecteur de porte qui détermine quelle part des informations passées doit être transmise pour la suite. Il applique une fonction sigmoïde à la somme de deux couches linéaires et un biais sur l'entrée $x_t$ et l'état précédent $h_{t-1}$. $z_t$ contient des coefficients entre 0 et 1 résultant de l'application de la fonction sigmoïde. L'état final de sortie $h_t$ est une combinaison convexe de $h_{t-1}$ et de $\phi_h(W_hx_t + U_h(r_t\odot h_{t-1}) + b_h)$ via $z_t$. Si le coefficient est égal à 1, la sortie de l'unité actuelle n'est qu'une copie de l'état précédent et ignore l'entrée (ce qui est le comportement par défaut). S'il est inférieur à 1, il prend en compte de nouvelles informations provenant de l'entrée. @@ -328,8 +325,6 @@ La porte de réinitialisation $r_t$ est utilisée pour décider quelle quantité - - -## LSTM (Long Short-Term Memory) +## Les LSTMs (*Long Short-Term Memory*) -GRU est en fait une version simplifiée de LSTM qui est sortie beaucoup plus tôt, [Hochreiter, Schmidhuber, 1997](https://www.bioinf.jku.at/publications/older/2604.pdf). En constituant des cellules de mémoire pour préserver les informations passées, les LSTM visent également à résoudre les problèmes de perte de mémoire à long terme dans les RNN. La structure des LSTM est présentée ci-dessous : +Les GRUs sont en fait une version simplifiée des LSTMs qui ont été conçues beaucoup plus tôt, [Hochreiter, Schmidhuber, 1997](https://www.bioinf.jku.at/publications/older/2604.pdf). En constituant des cellules de mémoire pour préserver les informations passées, les LSTMs visent également à résoudre les problèmes de perte de mémoire à long terme dans les RNNs. La structure des LSTMs est présentée ci-dessous :

-Figure 4. LSTM +Figure 4 : Long Short-Term Memory
@@ -382,7 +377,7 @@ où $\odot$ indique une multiplication par élément, $x_t\in\mathbb{R}^a$ est u Une unité LSTM utilise un état de cellule $c_t$ pour transmettre l'information. Elle régule la manière dont l'information est préservée ou retirée de l'état de la cellule par des structures appelées "gates" (portes). La porte d'oubli $f_t$ décide de la quantité d'informations que nous voulons conserver de l'état de cellule précédent $c_{t-1}$ en regardant l'entrée actuelle et l'état caché précédent. Elle produit un nombre entre 0 et 1 comme coefficient de $c_{t-1}$. $\tanh(W_cx_t + U_ch_{t-1} + b_c)$ calcule un nouveau candidat pour mettre à jour l'état de la cellule, et comme la porte d'oubli, la porte d'entrée $i_t$ décide de la part de mise à jour à appliquer. Enfin, la sortie $h_t$ sera basée sur l'état de la cellule $c_t$, mais passera par une $\tanh$ puis sera filtrée par la porte de sortie $o_t$. -Bien que les LSTM soient largement utilisés en NLP, leur popularité est en baisse. Par exemple, la reconnaissance vocale se dirige vers l'utilisation de ConvNets temporels, et les autres utilisations se dirigent vers l'utilisation de transformers. +Bien que les LSTMs soient largement utilisés en NLP, leur popularité est en baisse. Par exemple, la reconnaissance vocale se dirige vers l'utilisation de ConvNets temporels, et les autres utilisations se dirigent vers l'utilisation de transformers. -## [Aperçu](https://www.youtube.com/watch?v=8cAffg2jaT0&t=21s) +## [Vue d'ensemble](https://www.youtube.com/watch?v=8cAffg2jaT0&t=21s) Le RNN est un type d'architecture que nous pouvons utiliser pour traiter des séquences de données. Qu'est-ce qu'une séquence ? La leçon sur le RNN nous a appris qu'un signal peut être soit 1D, 2D ou 3D selon le domaine. Le domaine est défini par le point de départ et le point d'arrivée de la cartographie. Le traitement des données séquentielles concerne essentiellement les données 1D puisque le domaine est l'axe temporel. Néanmoins, vous pouvez également utiliser le RNN pour traiter des données 2D, où vous avez deux directions. @@ -51,31 +51,31 @@ Yann's diagram adds these shapes between neurons to represent the mapping betwee --> -### Vanilla vs RNN +### Architecture standard vs RNN -La figure 1 est un diagramme de réseau de neurones vanilla avec trois couches. "Vanilla" est un terme américain qui signifie "simple". La bulle rose est le vecteur d'entrée x, au centre se trouve la couche cachée en vert, et la dernière couche bleue est la sortie. En utilisant un exemple de l'électronique numérique à droite, c'est comme une logique combinatoire, où le courant de sortie ne dépend que du courant d'entrée. +La figure 1 est un diagramme de réseau de neurones vanilla avec trois couches. « Vanilla » est un terme américain signifiant « standard / de base ». La bulle rose est le vecteur d'entrée $x$, au centre se trouve la couche cachée en vert, et la dernière couche bleue est la sortie. En utilisant un exemple de l'électronique numérique à droite, c'est comme une logique combinatoire, où le courant de sortie ne dépend que du courant d'entrée.

-Figure 1: Architecture vanilla +Figure 1 : Architecture standard
-Contrairement à un réseau neuronal vanilla, dans les réseaux neuronaux récurrents la sortie de courant dépend non seulement de l'entrée mais aussi de l'état du système, comme le montre la figure 2. C'est comme une logique séquentielle dans l'électronique numérique, où la sortie dépend également d'une "bascule" (une unité de mémoire de base dans l'électronique numérique). La principale différence ici est donc que la sortie d'un réseau neuronal vanilla ne dépend que de l'entrée, tandis que celle d'un RNN dépend également de l'état du système. +Contrairement à un réseau neuronal standard, dans les réseaux neuronaux récurrents la sortie de courant dépend non seulement de l'entrée mais aussi de l'état du système, comme le montre la figure 2. C'est comme une logique séquentielle dans l'électronique numérique, où la sortie dépend également d'un intérupteur (une unité de mémoire de base dans l'électronique numérique). La principale différence ici est donc que la sortie d'un réseau neuronal standard ne dépend que de l'entrée, tandis que celle d'un RNN dépend également de l'état du système.
-
Figure 2: Architecture RNN +
Figure 2 : Architecture RNN

-Figure 3: Architecture d’un réseau de neurones de base +Figure 3 : Architecture d’un réseau de neurones de base
-Le diagramme de Yann ajoute ces formes entre les neurones pour représenter le mapping entre un tenseur et un autre (d'un vecteur à un autre). Par exemple, dans la figure 3, le vecteur d'entrée x va correspondre à travers cet élément supplémentaire aux représentations cachées h. Cet élément est en fait une transformation affine, c'est-à-dire une rotation plus une distorsion. Ensuite, par une autre transformation, nous passons de la couche cachée à la sortie finale. De même, dans le diagramme RNN, vous pouvez avoir les mêmes éléments supplémentaires entre les neurones. +Le diagramme de Yann ajoute ces formes entre les neurones pour représenter l'association entre un tenseur et un autre (d'un vecteur à un autre). Par exemple, dans la figure 3, le vecteur d'entrée x va correspondre à travers cet élément supplémentaire aux représentations cachées h. Cet élément est en fait une transformation affine, c'est-à-dire une rotation plus une distorsion. Ensuite, par une autre transformation, nous passons de la couche cachée à la sortie finale. De même, dans le diagramme RNN, vous pouvez avoir les mêmes éléments supplémentaires entre les neurones.
-
Figure 4: L'architecture RNN de Yann +
Figure 4 : L'architecture RNN de Yann
@@ -168,17 +168,17 @@ The fourth and final case is sequence to sequence. In this network, as you start ### Quatre types d'architectures RNN et des exemples -Le premier cas est celui du “vector to sequence” (un vecteur en entrée du réseau et on obtient une sequence en sortie de cleui-ci). L'entrée est une bulle et il y aura ensuite des évolutions de l'état interne du système annotées comme ces bulles vertes. À mesure que l'état du système évolue, il y aura une sortie spécifique à chaque étape. +Le premier cas est celui du « vector to sequence » (un vecteur en entrée du réseau et on obtient une sequence en sortie de cleui-ci). L'entrée est une bulle et il y aura ensuite des évolutions de l'état interne du système annotées comme ces bulles vertes. À mesure que l'état du système évolue, il y aura une sortie spécifique à chaque étape.

-Figure 5: Vec to Seq +Figure 5 : Vec to Seq
-Un exemple de ce type d'architecture est d'avoir comme entrée une image et comme sortie une séquence de mots représentant les descriptions de l'image d'entrée. Pour expliquer l'utilisation de la figure 6, chaque bulle bleue ici peut être un index dans un dictionnaire de mots. Par exemple, si la sortie est la phrase "This is a yellow school bus" ("C’est un bus scolaire jaune"). Vous obtenez d'abord l'index du mot "This", puis l'index du mot "is", et ainsi de suite. Certains des résultats de ce réseau sont présentés ci-dessous. Par exemple, dans la première colonne, la description concernant la dernière image est "A herd of elephants walking across a dry grass field" (Un troupeau d'éléphants marchant sur un champ d'herbe sèche"), ce qui est très bien précisé. Ensuite, dans la deuxième colonne, la première image donne "Two dogs play in the grass" ("Deux chiens jouent dans l'herbe"), alors qu'il s'agit en fait de trois chiens. Dans la dernière colonne, on trouve les exemples les plus erronés comme "A yellow school bus parked in a parking lot" ("Un bus scolaire jaune garé dans un parking"). En général, ces résultats montrent que ce réseau peut échouer de manière assez radicale et être parfois performant. C'est le cas d'un vecteur d'entrée, qui est la représentation d'une image, à une séquence de symboles, qui sont par exemple des caractères ou des mots composant les phrases. Ce type d'architecture est appelé un réseau autorégressif. Un réseau autorégressif est un réseau qui donne une sortie lorsque vous alimentez comme entrée la sortie précédente. +Un exemple de ce type d'architecture est d'avoir comme entrée une image et comme sortie une séquence de mots représentant les descriptions de l'image d'entrée. Pour expliquer l'utilisation de la figure 6, chaque bulle bleue ici peut être un index dans un dictionnaire de mots. Par exemple, si la sortie est la phrase « *This is a yellow school bus* » (« C’est un bus scolaire jaune »). Vous obtenez d'abord l'index du mot « *This* », puis l'index du mot « *is* », et ainsi de suite. Certains des résultats de ce réseau sont présentés ci-dessous. Par exemple, dans la première colonne, la description concernant la dernière image est « *A herd of elephants walking across a dry grass field* » (« Un troupeau d'éléphants marchant sur un champ d'herbe sèche »), ce qui est très bien précisé. Ensuite, dans la deuxième colonne, la première image donne « *Two dogs play in the grass* » (« Deux chiens jouent dans l'herbe »), alors qu'il s'agit en fait de trois chiens. Dans la dernière colonne, on trouve les exemples les plus erronés comme « *A yellow school bus parked in a parking lot* » (« Un bus scolaire jaune garé dans un parking »). En général, ces résultats montrent que ce réseau peut échouer de manière assez radicale et être parfois performant. C'est le cas d'un vecteur d'entrée, qui est la représentation d'une image, à une séquence de symboles, qui sont par exemple des caractères ou des mots composant les phrases. Ce type d'architecture est appelé un réseau autorégressif. Un réseau autorégressif est un réseau qui donne une sortie lorsque vous alimentez comme entrée la sortie précédente.
-
Figure 6: Exemple de vec2seq : De l'image au texte +
Figure 6 : Exemple de vec2seq : De l'image au texte
@@ -186,59 +186,59 @@ Le second type est le “sequence to vector”. Ce réseau continue à alimenter

-Figure 7: Seq to Vec +Figure 7 : Seq to Vec

-Figure 8: Lignes d'entrée des codes Python +Figure 8 : Lignes d'entrée des codes Python
Le réseau sera alors en mesure de produire la solution correcte de ce programme. Un autre programme plus compliqué comme celui-ci :
-
Figure 9: Lignes d'entrée des codes Python dans un cas plus complet +
Figure 9 : Lignes d'entrée des codes Python dans un cas plus complet
La sortie devrait alors être 12184. Ces deux exemples montrent que l'on peut entraîner un réseau de neurones à effectuer ce genre d'opération. Il suffit d'alimenter une séquence de symboles et de faire en sorte que la sortie finale soit une valeur spécifique. -La troisième est "sequence to vector to sequence", comme le montre la figure 10. Cette architecture était autrefois la méthode standard pour effectuer les traductions linguistiques. Vous commencez par une séquence de symboles illustrée ici en rose. Ensuite, tout est condensé dans ce h final, qui représente un concept. Par exemple, nous pouvons avoir une phrase comme entrée et la comprimer temporairement dans un vecteur, qui représente le sens et le message à transmettre. Ensuite, après avoir obtenu ce sens dans n'importe quelle représentation, le réseau le déroule dans une autre langue. Par exemple, "Today I'm very happy" dans une séquence de mots en anglais peut être traduit en italien ou en chinois. En général, le réseau reçoit une sorte d'encodage en entrée et le transforme en une représentation compressée. Enfin, il effectue le décodage en donnant la même version compressée. Ces derniers temps, nous avons vu des réseaux comme Transformers, que nous aborderons dans la prochaine leçon, surpasser cette méthode dans les tâches de traduction. Ce type d'architecture était à la pointe de la technologie il y a environ deux ans (2018). +La troisième est "sequence to vector to sequence", comme le montre la figure 10. Cette architecture était autrefois la méthode standard pour effectuer les traductions linguistiques. Vous commencez par une séquence de symboles illustrée ici en rose. Ensuite, tout est condensé dans ce h final, qui représente un concept. Par exemple, nous pouvons avoir une phrase comme entrée et la comprimer temporairement dans un vecteur, qui représente le sens et le message à transmettre. Ensuite, après avoir obtenu ce sens dans n'importe quelle représentation, le réseau le déroule dans une autre langue. Par exemple, « *Today I'm very happy* » dans une séquence de mots en anglais peut être traduit en italien ou en chinois. En général, le réseau reçoit une sorte d'encodage en entrée et le transforme en une représentation compressée. Enfin, il effectue le décodage en donnant la même version compressée. Ces derniers temps, nous avons vu des réseaux comme Transformers, que nous aborderons dans la prochaine leçon, surpasser cette méthode dans les tâches de traduction. Ce type d'architecture était à la pointe de la technologie il y a environ deux ans (2018).

-Figure 10: Seq to Vec to Seq +Figure 10 : Seq to Vec to Seq
Si vous faites une ACP sur l'espace latent, vous aurez les mots regroupés par sémantique comme indiqué dans ce graphique.

-Figure 11: Mots groupés par sémantique après l'ACP +Figure 11 : Mots groupés par sémantique après une ACP
Si nous faisons un zoom, nous verrons qu'au même endroit, il y a tous les mois, comme par exemple janvier et novembre.

-Figure 12: Zoom sur les groupes de mots +Figure 12 : Zoom sur les groupes de mots
-Si vous vous concentrez sur une autre région, vous obtenez des phrases comme "il y a quelques jours" ,"les prochains mois", etc. +Si vous vous concentrez sur une autre région, vous obtenez des phrases comme « il y a quelques jours », « les prochains mois », etc.

-Figure 13: Groupes de mots dans une autre région +Figure 13 : Groupes de mots dans une autre région
Ces exemples montrent que les différents lieux ont des significations communes spécifiques. -La figure 14 montre comment l’entraînement de ce type de réseau permet de saisir certaines caractéristiques sémantiques. Par exemple, dans ce cas, vous pouvez voir qu'il y a un vecteur reliant "man" à "woman" et un autre entre "king" et "queen". Cela signifie que "woman" - "man" = "queen" et "king". Vous obtiendrez la même distance dans cet espace appliqué aux cas comme homme-femme. +La figure 14 montre comment l’entraînement de ce type de réseau permet de saisir certaines caractéristiques sémantiques. Par exemple, dans ce cas, vous pouvez voir qu'il y a un vecteur reliant « *man* » à « *woman* » et un autre entre « *king* » et « *queen* ». Cela signifie que « *woman* » - « *man* » = « *queen* » et « *king* ». Vous obtiendrez la même distance dans cet espace appliqué aux cas comme homme-femme. Vous pouvez toujours appliquer ce type de transformation linéaire spécifique en passant d'un mot à un autre ou d'un pays à une capitale.

-Figure 14: Caractéristiques sémantiques choisies pendant l’entraînement +Figure 14 : Caractéristiques sémantiques choisies pendant l’entraînement
Le quatrième et dernier cas est celui du "sequence to sequence". Dans ce réseau, lorsque vous commencez à alimenter les entrées, le réseau commence à générer des sorties. Un exemple de ce type d'architecture est le T9, si vous vous souvenez d'avoir utilisé un téléphone Nokia, vous obtenez des suggestions de texte pendant que vous tapez. Un autre exemple est la generation de sous-titre depuis la voix. Un exemple intéressant est ce RNN-writer. Lorsque vous commencez à taper "les anneaux de Saturne scintillent pendant que", il suggère le texte suivant "deux hommes se regardent". Ce réseau a été entraîné sur certains romans de science-fiction afin que vous puissiez simplement taper quelque chose et le laisser vous faire des suggestions pour vous aider à écrire un livre. Un autre exemple est présenté à la figure 16. Vous saisissez la phrase du haut et ensuite ce réseau essaiera de compléter le reste. @@ -246,21 +246,21 @@ Le quatrième et dernier cas est celui du "sequence to sequence". Dans ce résea

-Figure 15: Séquence à Séquence +Figure 15 : Séquence à Séquence

-Figure 16: Modèle d'auto-gérénation de texte du modèle Seq to Seq +Figure 16 : Modèle d'auto-gérénation de texte du modèle Seq to Seq
+ ## [Rétropropagation à travers le temps](https://www.youtube.com/watch?v=8cAffg2jaT0&t=855s) - -### Batch-Ification en modélisation du langage +### Batch-ification en modélisation du langage Lorsqu'il s'agit d'une séquence de symboles, nous pouvons regrouper le texte en différentes tailles. Par exemple, lorsqu'il s'agit des séquences illustrées dans la figure suivante, la batch-ification peut être appliquée en premier lieu, lorsque le domaine temporel est préservé verticalement. Dans ce cas, la taille du batch est fixée à 4.

-Figure 18: Batch-Ification +Figure 18 : Batch-ification
Si la période $T$ de la BPTT est fixée à 3, la première entrée $x[1:T]$ et la sortie $y[1:T]$ pour RNN est déterminée comme @@ -399,7 +399,7 @@ Lors de l'exécution du RNN sur le premier batch, nous introduisons d'abord $x[1

-Figure 19: Batch-Ification +Figure 19 : Batch-ification
-### Architecture des LSTM +### Architecture des LSTMs -Vous trouverez ci-dessous des équations expliquant un LSTM. La porte d'entrée est mise en évidence par des cases jaunes, qui seront une transformation affine. Cette transformation d'entrée multipliera $c[t]$, qui est notre porte candidate. +Vous trouverez ci-dessous des équations expliquant une LSTM. La porte d'entrée est mise en évidence par des cases jaunes, qui seront une transformation affine. Cette transformation d'entrée multipliera $c[t]$, qui est notre porte candidate.

-Figure 22: Architecture d’un réseau LSTM +Figure 22 : Architecture d’un réseau LSTM
-La "Don't forget gate" sur le graphique multiplie la valeur précédente de la mémoire cellulaire $c[t-1]$. La valeur totale de la cellule $c[t]$ est égale à la somme de "Don't forget gate" et de "Input gate". La représentation cachée finale est une multiplication par élément entre la porte de sortie $o[t]$ et la version tangente hyperbolique de la cellule $c[t]$, de sorte que les choses sont limitées. Enfin, la porte candidate $\tilde{c}[t]$ est simplement un réseau récurrent. Nous avons donc un $o[t]$ pour moduler la sortie, un $f[t]$ pour moduler la porte "don't forget", et un $i[t]$ pour moduler la porte d'entrée. Toutes ces interactions entre la mémoire et les portes sont des interactions multiplicatives. $i[t]$, $f[t]$ et $o[t]$ sont tous des sigmoïdes, allant de zéro à un. Par conséquent, en multipliant par zéro, vous obtenez une porte fermée. En multipliant par un, vous avez une porte ouverte. +La « *Don't forget gate* » sur le graphique multiplie la valeur précédente de la mémoire cellulaire $c[t-1]$. La valeur totale de la cellule $c[t]$ est égale à la somme de « *Don't forget gate*» et de "Input gate". La représentation cachée finale est une multiplication par élément entre la porte de sortie $o[t]$ et la version tangente hyperbolique de la cellule $c[t]$, de sorte que les choses sont limitées. Enfin, la porte candidate $\tilde{c}[t]$ est simplement un réseau récurrent. Nous avons donc un $o[t]$ pour moduler la sortie, un $f[t]$ pour moduler la porte "don't forget", et un $i[t]$ pour moduler la porte d'entrée. Toutes ces interactions entre la mémoire et les portes sont des interactions multiplicatives. $i[t]$, $f[t]$ et $o[t]$ sont tous des sigmoïdes, allant de zéro à un. Par conséquent, en multipliant par zéro, vous obtenez une porte fermée. En multipliant par un, vous avez une porte ouverte. Comment éteindre la sortie ? Supposons que nous ayons une représentation interne violette $th$ et que nous mettions un zéro dans la porte de sortie. La sortie sera alors zéro multiplié par quelque chose, et nous aurons un zéro. Si nous mettons un un dans la porte de sortie, nous obtiendrons la même valeur que la représentation en violet.

-Figure 23: Architecture LSTM - Sortie activée +Figure 23 : Architecture LSTM - Sortie activée

-Figure 24: Architecture LSTM - Sortie désactivée +Figure 24 : Architecture LSTM - Sortie désactivée
-De même, nous pouvons contrôler la mémoire. Par exemple, nous pouvons la réinitialiser en faisant en sorte que $f[t]$ et $i[t]$ soient des zéros. Après multiplication et sommation, nous avons un zéro dans la mémoire. Sinon, nous pouvons conserver la mémoire, en mettant toujours à zéro la représentation interne $th$ mais en gardant un un dans $f[t]$. Ainsi, la somme obtient $c[t-1]$ et continue à l'envoyer. Enfin, nous pouvons écrire de manière à obtenir un un dans la porte d'entrée, la multiplication devient violette, puis mettre un zéro dans la porte "don't forget" pour qu'elle oublie réellement. +De même, nous pouvons contrôler la mémoire. Par exemple, nous pouvons la réinitialiser en faisant en sorte que $f[t]$ et $i[t]$ soient des zéros. Après multiplication et sommation, nous avons un zéro dans la mémoire. Sinon, nous pouvons conserver la mémoire, en mettant toujours à zéro la représentation interne $th$ mais en gardant un un dans $f[t]$. Ainsi, la somme obtient $c[t-1]$ et continue à l'envoyer. Enfin, nous pouvons écrire de manière à obtenir un un dans la porte d'entrée, la multiplication devient violette, puis mettre un zéro dans la porte « *don't forget* » pour qu'elle oublie réellement.

-Figure 25: Visualisation de la cellule mémoire +Figure 25 : Visualisation de la cellule mémoire

-Figure 26: Architecture LSTM - Réinitialisation de la mémoire +Figure 26 : Architecture LSTM - Réinitialisation de la mémoire

-Figure 27: LSTM Architecture - Conserver la mémoire +Figure 27 : Architecture STM - Conserver la mémoire

-Figure 28: LSTM Architecture - Mémoire d'écriture +Figure 28 : Architecture LSTM - Mémoire d'écriture
### L'écho du signal + +Cette section se réfère au code du *notebook* Jupyter trouvable [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/09-echo_data.ipynb) pour la version en anglais et [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/09-echo_data.ipynb) pour la version en français. L'écho du signal n étapes est un exemple de tâche synchronisée de plusieurs à plusieurs. Par exemple, la 1ère séquence d'entrée est `1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 ...`, et la 1ère séquence cible est `0 0 0 1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 ...`. Dans ce cas, la sortie se fait trois étapes plus tard. Nous avons donc besoin d'une mémoire de travail de courte durée pour conserver les informations. Alors que dans le modèle linguistique, cela revient à dire quelque chose qui n'a pas encore été dit. -Avant d'envoyer la séquence complète au réseau et de forcer la cible finale à être quelque chose, nous devons couper la longue séquence en petits morceaux. Tout en alimentant un nouveau morceau, nous devons garder une trace de l'état caché et l'envoyer comme entrée à l'état interne lors de l'ajout du nouveau morceau suivant. Dans les LSTM, vous pouvez conserver la mémoire pendant une longue période tant que vous avez une capacité suffisante. Dans les RNN, une fois que vous avez atteint une certaine longueur, la mémoire commence à oublier ce qui s'est passé dans le passé. +Avant d'envoyer la séquence complète au réseau et de forcer la cible finale à être quelque chose, nous devons couper la longue séquence en petits morceaux. Tout en alimentant un nouveau morceau, nous devons garder une trace de l'état caché et l'envoyer comme entrée à l'état interne lors de l'ajout du nouveau morceau suivant. Dans les LSTMs, vous pouvez conserver la mémoire pendant une longue période tant que vous avez une capacité suffisante. Dans les RNNs, une fois que vous avez atteint une certaine longueur, la mémoire commence à oublier ce qui s'est passé dans le passé. diff --git a/docs/fr/week06/06.md b/docs/fr/week06/06.md index 63c1a5fef..f659bae90 100644 --- a/docs/fr/week06/06.md +++ b/docs/fr/week06/06.md @@ -13,7 +13,7 @@ We discussed three applications of convolutional neural networks. We started wit --> -## Conférence partie A +## Cours magistral partie A Nous discutons de trois applications des réseaux de neurones convolutifs. Nous commençons par la reconnaissance de chiffres avec l'application à une reconnaissance de code postal à 5 chiffres. En ce qui concerne la détection d'objets, nous abordons la manière d'utiliser une architecture multi-échelle dans un cadre de détection de visages. Enfin, nous voyons comment les ConvNets sont utilisés dans des tâches de segmentation sémantique avec des exemples concrets dans un système de vision robotique et la segmentation d'objets dans un environnement urbain. @@ -23,9 +23,9 @@ Nous discutons de trois applications des réseaux de neurones convolutifs. Nous We examine Recurrent Neural Networks, their problems, and common techniques for mitigating these issues. We then review a variety of modules developed to resolve RNN model issues including Attention, GRUs (Gated Recurrent Unit), LSTMs (Long Short-Term Memory), and Seq2Seq. --> -## Conférence partie B +## Cours magistral partie B -Nous examinons les réseaux neuronaux récurrents, leurs problèmes et les techniques courantes permettant d'atténuer ces problèmes. Nous examinons ensuite divers modules développés pour résoudre les problèmes liés aux modèles RNN, notamment l’Attention, les GRUs (Gated Recurrent Unit), les LSTMs (Long Short-Term Memory) et le Seq2Seq. +Nous examinons les réseaux neuronaux récurrents, leurs problèmes et les techniques courantes permettant d'atténuer ces problèmes. Nous examinons ensuite divers modules développés pour résoudre les problèmes liés aux modèles RNNs, notamment l’Attention, les GRUs (*Gated Recurrent Unit*), les LSTMs (*Long Short-Term Memory*) et le Seq2Seq. -## Pratique -Nous discutons de l'architecture des modèles Vanilla RNN et LSTM et comparons les performances entre les deux. LSTM hérite des avantages de RNN, tout en améliorant ses faiblesses en incluant une "cellule mémoire" afin de stocker les informations en mémoire pendant de longues périodes. Les modèles LSTM sont nettement plus performants que les modèles RNN. - +## Travaux dirigés +Nous discutons de l'architecture des modèles RNN de base et des LSTMs et comparons les performances entre les deux. Les LSTMs héritent des avantages de RNN, tout en améliorant ses faiblesses en incluant une cellule mémoire afin de stocker les informations pendant de longues périodes. Les modèles LSTMs sont nettement plus performants que les modèles RNNs. diff --git a/docs/fr/week07/07-1.md b/docs/fr/week07/07-1.md index 94b9cd3e8..9f5d714be 100644 --- a/docs/fr/week07/07-1.md +++ b/docs/fr/week07/07-1.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.07-1 lecturer: Yann Le Cun -title: Modèles à base d’énergie (EBM) +title: Modèles à base d’énergie (EBMs) authors: Karanbir Singh Chahal,Meiyi He, Alexander Gao, Weicheng Zhu date: 9 Mar 2020 translation-date: 07 Aug 2020 @@ -18,12 +18,13 @@ We will introduce a new framework for defining models. It provides a unifying um 2. What if there are multiple possible outputs for a single input? Example: Predicting future frames of video. Essentially in a classification net, we train this net to emit a score for each class. However, this is not possible to do in a continuous high dimensional domain like images. (We cannot have softmax over images!). Even if the output is discrete, it could have a large sample space. For example, the text is compositional leading to a huge number of possible combinations. Energy-based models provide a better framework to model these modalities. --> -## [Aperçu](https://www.youtube.com/watch?v=tVwV14YkbYs&t=64s) +## [Vue d'ensemble](https://www.youtube.com/watch?v=tVwV14YkbYs&t=64s) -Nous allons introduire un nouveau cadre pour la définition des modèles. Il fournit un parapluie unificateur qui aide à définir des modèles supervisés, non supervisés et auto-supervisé. Les modèles à base d’énergie (EBM) observent un ensemble de variables $x$ et produisent un ensemble de variables $y$. Les réseaux feed-forward posent deux problèmes majeurs : +Nous allons introduire un nouveau cadre pour la définition des modèles. Il fournit un parapluie unificateur qui aide à définir des modèles supervisés, non supervisés et autosupervisé. Les modèles à base d’énergie (EBMs) observent un ensemble de variables $x$ et produisent un ensemble de variables $y$. Les réseaux feed-forward posent deux problèmes majeurs : 1. Que faire si la procédure d'inférence est un calcul plus complexe que des couches empilées de sommes pondérées ? -2. Que faire s'il y a plusieurs résultats possibles pour une seule entrée ? Exemple : Prévision des futures images d’une vidéo. Essentiellement dans un réseau de classification, nous entraînons ce réseau à émettre un score pour chaque classe. Toutefois, cela n'est pas possible dans un domaine continu à haute dimension comme les images. (Nous ne pouvons pas avoir de softmax sur les images !). Même si la sortie est discrète, elle pourrait avoir un grand espace d'échantillonnage. Le texte est compositionnel, ce qui conduit à un grand nombre de combinaisons possibles. Les modèles basés sur l'énergie fournissent un meilleur cadre pour modéliser ces modalités. +2. Que faire s'il y a plusieurs résultats possibles pour une seule entrée comme par exemple la prévision des images futures dans une vidéo ? +Dans un réseau de classification, nous entraînons ce réseau à émettre un score pour chaque classe. Toutefois, cela n'est pas possible dans un domaine continu à haute dimension comme les images : nous ne pouvons pas avoir de softmax sur les images ! Même si la sortie est discrète, elle pourrait avoir un grand espace d'échantillonnage. Le texte est compositionnel, ce qui conduit à un grand nombre de combinaisons possibles. Les modèles basés sur l'énergie fournissent un meilleur cadre pour modéliser ces modalités. -## L’approche des EBM +## L’approche des EBMs Au lieu d'essayer de classer les $x$ à $y$, nous aimerions prédire si une certaine paire de ($x$, $y$) s'assemble ou non. Ou, en d'autres termes, trouver un $y$ compatible avec $x$. Nous pouvons également poser le problème de trouver un $y$ pour lequel certains $F(x,y)$ sont faibles. Par exemple : +- est-ce que $y$ est une image haute résolution précise de $x$ ? +- le texte "A" est-il une bonne traduction du texte "B" ? -- Est-ce que $y$ est une image haute résolution précise de $x$ ? -- Le texte "A" est-il une bonne traduction du texte "B" ? - -Cette méthode d'inférence par minimisation d'une fonction et une grande classe de modèles fonctionnent de cette façon. En minimisant $f(x,y)$ ou "énergie". Par conséquent, nous effectuons l'inférence en minimisant les contraintes lorsque ces contraintes sont représentées par $f(x,y)$. Nous appellerons dorénavant $f(x,y)$ la "fonction énergie". +Cette méthode d'inférence par minimisation d'une fonction et une grande classe de modèles fonctionnent de cette façon. En minimisant $f(x,y)$ ou **énergie**. Par conséquent, nous effectuons l'inférence en minimisant les contraintes lorsque ces contraintes sont représentées par $f(x,y)$. Nous appellerons dorénavant $f(x,y)$ la **fonction d'énergie**. -## [EBM avec variables latentes](https://www.youtube.com/watch?v=tVwV14YkbYs&t=904s) +## [EBMs à variables latentes](https://www.youtube.com/watch?v=tVwV14YkbYs&t=904s) -La sortie $y$ dépend de $x$ ainsi que d'une variable supplémentaire $z$ (la variable latente) dont nous ne connaissons pas la valeur. Ces variables latentes peuvent fournir des informations auxiliaires. Par exemple, une variable latente peut vous indiquer la position des limites des mots dans un morceau de texte. Cela serait utile pour savoir quand nous voulons interpréter une écriture sans espaces. C'est aussi particulièrement utile pour les discours qui peuvent présenter des lacunes difficiles à déchiffrer. En outre, certaines langues ont des limites de mots très faibles (par exemple le français). Par conséquent, la présence de cette variable latente dans notre modèle sera très utile pour interpréter une telle donnée. +La sortie $y$ dépend de $x$ ainsi que d'une variable supplémentaire $z$ (la variable latente) dont nous ne connaissons pas la valeur. Ces variables latentes peuvent fournir des informations auxiliaires. Par exemple, elle peut vous indiquer la position des limites des mots dans un morceau de texte. Cela serait utile pour savoir quand nous voulons interpréter une écriture sans espaces. C'est aussi particulièrement utile pour les discours qui peuvent présenter des lacunes difficiles à déchiffrer. En outre, certaines langues ont des limites de mots très faibles comme par exemple le français. Par conséquent, la présence de cette variable latente dans notre modèle est très utile pour interpréter une telle donnée. -## [EBM *v.s.* modèles probabilistes](https://www.youtube.com/watch?v=tVwV14YkbYs&t=1703s) +## [Les EBMs *vs* les modèles probabilistes](https://www.youtube.com/watch?v=tVwV14YkbYs&t=1703s) -Nous pouvons considérer les énergies comme des probabilités logarithmiques négatives non normalisées, et utiliser la distribution de Gibbs-Boltzmann pour convertir l'énergie en probabilité après normalisation qui est : +Nous pouvons considérer les énergies comme des probabilités logarithmiques négatives non normalisées et utiliser la distribution de Gibbs-Boltzmann pour convertir l'énergie en probabilité après normalisation qui est : $$P(y \mid x) = \frac{\exp (-\beta F(x,y))}{\int_{y'}\exp(-\beta F(x,y'))}$$ -où $\beta$ est une constante positive et doit être calibré pour s'adapter à votre modèle. Un plus grand $\beta$ donne un modèle plus fluctuant tandis qu’un plus petit $\beta$ donne un modèle plus lisse. (En physique, $\beta$ est la température inverse : $\beta \rightarrow \infty$ signifie que la température va jusqu'à zéro). +où $\beta$ est une constante positive et doit être calibré pour s'adapter à votre modèle. +Un plus grand $\beta$ donne un modèle plus fluctuant tandis qu’un plus petit $\beta$ donne un modèle plus lisse. En physique, $\beta$ est la température inverse : $\beta \rightarrow \infty$ signifie que la température va jusqu'à zéro. $$P(y,z \mid x) = \frac{\exp(-\beta F(x,y,z))}{\int_{y}\int_{z}\exp(-\beta F(x,y,z))}$$ @@ -194,7 +196,7 @@ P(y \mid x) & = \frac{\int_z \exp(-\beta E(x,y,z))}{\int_y\int_z \exp(-\beta E(x \end{aligned} $$ -Ainsi, si nous disposons d'un modèle à variable latente et que nous voulons éliminer la variable latente $z$ de manière probabiliste, il suffit de redéfinir la fonction énergie $F_\beta$ (énergie libre) +Ainsi, si nous disposons d'un modèle à variable latente et que nous voulons éliminer la variable latente $z$ de manière probabiliste, il suffit de redéfinir la fonction d'énergie $F_\beta$ : l'énergie libre. -### Énergie libre +### L'énergie libre + $$ F_{\beta}(x,y) = - \frac{1}{\beta}\log \int_z \exp (-\beta E(x,y,z)) $$ -Calculer cela peut être très difficile... En fait, dans la plupart des cas, c'est probablement insoluble. Donc si vous avez une variable latente que vous voulez minimiser à l'intérieur de votre modèle, ou si vous avez une variable latente que vous voulez marginaliser (ce que vous faites en définissant cette fonction d'énergie $F$), et que la minimisation correspond à la limite infinie $\beta$ de cette formule, alors c'est possible. -Selon la définition de $F_\beta(x, y)$ ci-dessus, $P(y \mid x)$ n'est qu'une application de la formule de Gibbs-Boltzmann et $z$ a été implicitement marginalisé à l'intérieur de celle-ci. Les physiciens appellent cela "énergie libre", c'est pourquoi nous l'appelons $F$ (pour free en anglais). Donc $e$ est l'énergie, et $F$ est l'énergie libre. +Calculer ceci peut être très difficile. En fait, dans la plupart des cas, c'est probablement insoluble. Donc si vous avez une variable latente que vous voulez minimiser à l'intérieur de votre modèle ou si vous avez une variable latente que vous voulez marginaliser (ce que vous faites en définissant cette fonction d'énergie $F$) et que la minimisation correspond à la limite infinie $\beta$ de cette formule, alors c'est possible. + +Selon la définition de $F_\beta(x, y)$ ci-dessus, $P(y \mid x)$ n'est qu'une application de la formule de Gibbs-Boltzmann et $z$ a été implicitement marginalisé à l'intérieur de celle-ci. Les physiciens appellent cela l'**énergie libre**, c'est pourquoi nous l'appelons $F$ (*free energy* en anglais). +Donc $e$ est l'énergie et $F$ est l'énergie libre. -***Question : Pouvez-vous nous parler de l'avantage qu'offrent les modèles à base d’énergie ? Dans les modèles basés sur les probabilités, vous pouvez également avoir des variables latentes, qui peuvent être marginalisées.*** -La différence est que dans les modèles probabilistes, vous n'avez pas le choix de la fonction objectif que vous allez minimiser, et vous devez rester fidèle au cadre probabiliste au sens que chaque objet que vous manipulez doit être une distribution normalisée (que vous pouvez approximer en utilisant des méthodes variationnelles, etc…). Nous disons ici qu'en fin de compte, ce que vous voulez faire avec ces modèles, c'est prendre des décisions. Si vous construisez un système qui conduit une voiture, et que le système vous dit "Je dois tourner à gauche avec une probabilité de 0,8 ou tourner à droite avec une probabilité de 0,2", vous allez tourner à gauche. Le fait que les probabilités soient de 0,2 et 0,8 n'a pas d'importance : ce que vous voulez, c'est prendre la meilleure décision, parce que vous êtes obligé de prendre une décision. Les probabilités sont donc inutiles si vous voulez prendre des décisions. Si vous voulez combiner la sortie d'un système automatisé avec un autre (par exemple, un système humain ou autre), et que ces systèmes n'ont pas été formés ensemble, mais plutôt séparément, alors ce que vous voulez, ce sont des scores calibrés pour que vous puissiez combiner les scores des deux systèmes afin de prendre une bonne décision. Il n'y a qu'une seule façon de calibrer les scores, et c'est de les transformer en probabilités. Tous les autres moyens sont soit inférieurs, soit équivalents. Mais si vous voulez entraîner un système de bout en bout à la prise de décision, alors n'importe quelle fonction de notation que vous utilisez est bonne, à condition qu'elle donne le meilleur score à la meilleure décision. -Les EBM vous donnent beaucoup plus de choix quant à la façon dont vous manipulez le modèle, peut-être même plus de choix quant à la façon dont vous l'entraînez et quant à la fonction objectif que vous utilisez. Si vous insistez pour que votre modèle soit probabiliste, vous devez utiliser le maximum de vraisemblance - vous devez essentiellement entraîner votre modèle de telle manière que la probabilité qu'il donne aux données que vous avez observées soit maximale. Le problème est que l'on ne peut prouver que cela fonctionne que si votre modèle est "correct" - et votre modèle n'est jamais "correct". Le célèbre statisticien Goerge Box a dit : ***"Tous les modèles sont faux, mais certains sont utiles"***. Les modèles probabilistes, en particulier ceux dans les espaces à haute dimension et dans les espaces combinatoires comme le texte, sont donc tous des modèles approximatifs. Ils sont tous erronés d'une certaine manière, et si vous essayez de les normaliser, vous les rendez encore plus erronés. Il est donc préférable de ne pas les normaliser. +### Quels sont les avantages qu'offrent les modèles à base d’énergie ? +En effet, dans les modèles basés sur les probabilités, il est aussi possible d'avoir des variables latentes qui peuvent être marginalisées. + +La différence est que dans les modèles probabilistes, vous n'avez pas le choix de la fonction objectif que vous allez minimiser. Et vous devez rester fidèle au cadre probabiliste au sens que chaque objet que vous manipulez doit être une distribution normalisée (que vous pouvez approximer en utilisant des méthodes variationnelles, etc.). Nous disons ici qu'en fin de compte, ce que vous voulez faire avec ces modèles, c'est prendre des décisions. Si vous construisez un système qui conduit une voiture et que le système vous dit « Je dois tourner à gauche avec une probabilité de 0,8 ou tourner à droite avec une probabilité de 0,2 », vous allez tourner à gauche. Le fait que les probabilités soient de 0,2 et 0,8 n'a pas d'importance. Ce que vous voulez, c'est prendre la meilleure décision, parce que vous êtes obligés de prendre une décision. Les probabilités sont donc inutiles si vous voulez prendre des décisions. Si vous voulez combiner la sortie d'un système automatisé avec un autre (par exemple, un système humain ou autre) et que ces systèmes n'ont pas été entraînés ensemble, mais plutôt séparément, alors ce que vous voulez, ce sont des scores calibrés pour que vous puissiez combiner les scores des deux systèmes afin de prendre une bonne décision. Il n'y a qu'une seule façon de calibrer les scores et c'est de les transformer en probabilités. Tous les autres moyens sont soit inférieurs, soit équivalents. Mais si vous voulez entraîner un système de bout en bout à la prise de décision, alors n'importe quelle fonction de notation que vous utilisez est bonne, à condition qu'elle donne le meilleur score à la meilleure décision. +Les EBMs vous donnent beaucoup plus de choix quant à la façon dont vous manipulez le modèle, peut-être même plus de choix sur la manière dont vous l'entraînez et pour la fonction objectif que vous utilisez. Si vous insistez pour que votre modèle soit probabiliste, vous devez utiliser le maximum de vraisemblance. Vous devez essentiellement entraîner votre modèle de telle manière que la probabilité qu'il donne aux données que vous avez observées soit maximale. Le problème est que l'on ne peut prouver que cela fonctionne que si votre modèle est « correct » mais votre modèle n'est jamais « correct ». Le statisticien Goerge Box a dit : ***« Tous les modèles sont faux mais certains sont utiles »***. Les modèles probabilistes, en particulier ceux dans les espaces en grandes dimensions et dans les espaces combinatoires comme le texte, sont donc tous des modèles approximatifs. Ils sont tous erronés d'une certaine manière, et si vous essayez de les normaliser, vous les rendez encore plus erronés. Il est donc préférable de ne pas les normaliser.

-Fig. 2: Visualisation de la fonction énergie qui saisit la dépendance entre x et y +Figure 2 : Visualisation de la fonction d'énergie qui saisit la dépendance entre x et y
-Il s'agit d'une fonction énergie qui vise à capturer la dépendance entre *x* et *y*. C'est comme une chaîne de montagnes si vous voulez. Les vallées sont là où se trouvent les points noirs (ce sont des points de données), et il y a des montagnes tout autour. Maintenant, si vous entraînez un modèle probabiliste avec cela, imaginez que les points sont en fait sur une surface infiniment mince. La distribution des données pour les points noirs n'est donc en fait qu'une ligne, et il y en a trois. Ils n'ont en fait aucune largeur. Donc si vous entraînez un modèle probabiliste sur ce point, votre modèle de densité devrait vous dire quand vous êtes sur cette surface. Sur cette surface, la densité est infinie, et toutes $\varepsilon$ en dehors d'elle devrait être zéro. Ce serait le modèle correct de cette distribution. Non seulement la densité doit être infinie, mais l'intégrale sur [x et y] doit être égale à 1. C'est très difficile à mettre en œuvre sur ordinateur ! Non seulement cela, mais c'est aussi fondamentalement impossible. Supposons que vous vouliez calculer cette fonction par une sorte de réseau neuronal. Celui-ci devra avoir des poids infinis et ils devront être calibrés de telle sorte que l'intégrale de la sortie de ce système sur l'ensemble du domaine soit de 1. C'est pratiquement impossible. Le modèle probabiliste précis et correct pour cet exemple particulier de données est impossible. C'est ce que le maximum de vraisemblance voudra que vous produisiez, et il n'y a aucun ordinateur au monde qui puisse calculer cela. Donc, en fait, ce n'est même pas intéressant. Imaginez que vous ayez le modèle de densité parfait pour cet exemple, qui est une fine plaque dans cet espace (x, y) -- vous ne pourriez pas faire d'inférence ! Si je vous donne une valeur de x, et que je vous demande "quelle est la meilleure valeur de y ?" Vous ne pourriez pas la trouver car toutes les valeurs de y, sauf un ensemble de probabilité zéro, ont une probabilité de zéro, et il n'y a que quelques valeurs possibles. Pour ces valeurs de x par exemple : +Il s'agit d'une fonction d'énergie qui vise à capturer la dépendance entre *x* et *y*. C'est comme une chaîne de montagnes si vous voulez. Les vallées sont là où se trouvent les points noirs (ce sont des points de données) et il y a des montagnes tout autour. Maintenant, si vous entraînez un modèle probabiliste avec cela, imaginez que les points sont en fait sur une surface infiniment mince. La distribution des données pour les points noirs n'est donc en fait qu'une ligne, et il y en a trois. Ils n'ont en fait aucune largeur. Donc si vous entraînez un modèle probabiliste sur ce point, votre modèle de densité devrait vous dire quand vous êtes sur cette surface. Sur cette surface, la densité est infinie, et toutes $\varepsilon$ en dehors d'elle devrait être zéro. Ce serait le modèle correct de cette distribution. Non seulement la densité doit être infinie, mais l'intégrale sur [x et y] doit être égale à 1. C'est très difficile à mettre en œuvre sur ordinateur ! Non seulement cela, mais c'est aussi fondamentalement impossible. Supposons que vous vouliez calculer cette fonction par une sorte de réseau neuronal. Celui-ci devra avoir des poids infinis et ils devront être calibrés de telle sorte que l'intégrale de la sortie de ce système sur l'ensemble du domaine soit de 1. C'est pratiquement impossible. Le modèle probabiliste précis et correct pour cet exemple particulier de données est impossible. C'est ce que le maximum de vraisemblance voudra que vous produisiez et il n'y a aucun ordinateur au monde qui puisse calculer cela. Donc, en fait, ce n'est même pas intéressant. Imaginez que vous ayez le modèle de densité parfait pour cet exemple, qui est une fine plaque dans cet espace (x, y), vous ne pourriez pas faire d'inférence ! Si on vous donne une valeur de x et qu'on vous demande quelle est la meilleure valeur de y, vous ne pourriez pas la trouver car toutes les valeurs de y. Sauf un ensemble de probabilité zéro ont une probabilité de zéro et il n'y a que quelques valeurs possibles. Pour ces valeurs de x par exemple : +

-Fig. 3: Exemple de prédiction multiple de l'EBM en tant que fonction implicite
+Figure 3 : Exemple de prédiction multiple de l'EBM en tant que fonction implicite + +
-Il y a 3 valeurs de y qui sont possibles, et elles sont infiniment étroites. Il n'y a pas d'algorithme d'inférence qui vous permettra de les trouver. La seule façon de les trouver est de rendre votre fonction de contraste lisse et différentiable, et alors vous pouvez partir de n'importe quel point et par descente de gradient vous pouvez trouver une bonne valeur pour y pour n'importe quelle valeur de x. Mais ce ne sera pas un bon modèle probabiliste de la distribution si la distribution est du type que j'ai mentionné. Voici donc un cas où insister pour avoir un bon modèle probabiliste est en fait mauvais. Le maximum de vraisemblance est nul dans ce cas ! +Il y a 3 valeurs de y qui sont possibles et elles sont infiniment étroites. Il n'y a pas d'algorithme d'inférence qui vous permettra de les trouver. La seule façon de le faire est de rendre votre fonction de contraste lisse et différentiable. Alors vous pouvez partir de n'importe quel point et par descente de gradient vous pouvez trouver une bonne valeur pour y pour n'importe quelle valeur de x. Mais ce ne sera pas un bon modèle probabiliste de la distribution si la distribution est comme celle mentionnée. Voici donc un cas où insister pour avoir un bon modèle probabiliste est en fait mauvais. Le maximum de vraisemblance est néfaste dans ce cas ! -Donc si vous êtes un vrai Bayésien, vous dites "oh mais vous pouvez corriger cela en ayant un apriori fort où l’apriori dit que votre fonction de densité doit être lisse". Vous pouvez considérer cela comme un apriori. Mais, tout ce que vous faites en termes bayésiens - prenez le logarithme de celui-ci, oubliez la normalisation - vous obtenez des modèles basés sur l'énergie. Les EBM qui ont un régularisateur, qui est additif à votre fonction énergie, sont complètement équivalents aux modèles bayésiens où la vraisemblance de l'énergie est exponentielle. Maintenant vous obtenez $\exp(\text{énergie}) \exp(\text{régulateur})$, et donc c'est égal à $\exp(\text{énergie} + \text{régulateur})$. Et si vous supprimez l'exponentielle, vous obtenez un modèle basé sur l'énergie avec un régularisateur additif. +Si vous êtes un Bayésien, vous dites « oh mais vous pouvez corriger cela en ayant un a priori fort indiquant que votre fonction de densité doit être lisse ». +Mais, tout ce que vous faites en termes bayésiens (mathèmatiquement parlant), vous mène aux modèles à base d'énergie. Les EBMs qui ont un régulariseur, qui est additif à votre fonction d'énergie, sont complètement équivalents aux modèles bayésiens où la vraisemblance de l'énergie est exponentielle. Maintenant vous obtenez $\exp(\text{énergie}) \exp(\text{régulateur})$ et donc c'est égal à $\exp(\text{énergie} + \text{régulateur})$. Si vous supprimez l'exponentielle, vous obtenez un modèle à base d'énergie avec un régulariseur additif. -Il y a donc là une correspondance entre les méthodes probabilistes et bayésiennes, mais ayez en tête que faire le maximum de vraisemblance est parfois mauvais pour vous, en particulier dans les espaces à haute dimension ou les espaces combinatoires où votre modèle probabiliste est très erroné. Il n'est pas très erroné dans les distributions discrètes (c'est correct) mais dans les cas continus, il peut être vraiment erroné. Et tous les modèles sont erronés. +Il y a donc là une correspondance entre les méthodes probabilistes et bayésiennes, mais ayez en tête que faire le maximum de vraisemblance est parfois néfaste pour vous, en particulier dans les espaces en grandes dimensions ou les espaces combinatoires où votre modèle probabiliste est très erroné. Cela n'est pas très erroné dans les distributions discrètes (c'est correct) mais dans les cas continus, cela peut être vraiment erroné. Et tous les modèles sont erronés. diff --git a/docs/fr/week07/07-2.md b/docs/fr/week07/07-2.md index 709d11749..80f0e63de 100644 --- a/docs/fr/week07/07-2.md +++ b/docs/fr/week07/07-2.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.07-2 lecturer: Yann Le Cun -title: Apprentissage auto-supervisé, EBM en details et des examples +title: Apprentissage autosupervisé, les détails des EBMs et exemples authors: Ravi Choudhary, B V Nithish Addepalli, Syed Rahman,Jiayi Du translation-date: 07 Aug 2020 translator: Loïck Bourdois @@ -40,32 +40,32 @@ A neural network trained using Least Squares to predict the next frame of a vide --> -## [Apprentissage auto-supervisé](https://www.youtube.com/watch?v=tVwV14YkbYs&t=2683s) +## [Apprentissage autosupervisé](https://www.youtube.com/watch?v=tVwV14YkbYs&t=2683s) -L'apprentissage auto-supervisé (SSL en anglais pour Self Supervised Learning) englobe à la fois l'apprentissage supervisé et non supervisé. L'objectif du SSL est d'apprendre une bonne représentation de l'entrée afin qu'elle puisse ensuite être utilisée pour des tâches supervisées. En SSL, le modèle est entraîné pour prédire une partie des données en fonction d'autres parties des données. Par exemple, BERT a été entraîné en utilisant le SSL et l'auto-encodeur débruiteur (Denoising Auto-Encoder : DAE) a notamment montré des résultats de pointe en matière de traitement du langage naturel (NLP pour Natural Language Processing). +L'apprentissage autosupervisé (pouvant être abrgé en SSL pour *Self-Supervised Learning*) englobe à la fois l'apprentissage supervisé et non supervisé. L'objectif du SSL est d'apprendre une bonne représentation de l'entrée afin qu'elle puisse ensuite être utilisée pour des tâches supervisées. En SSL, le modèle est entraîné pour prédire une partie des données en fonction d'autres parties des données. Par exemple, BERT a été entraîné en combinant le SSL et l'auto-encodeur débruiteur. Ce modèle a montré des résultats de pointe en traitement du langage naturel (NLP pour *Natural Language Processing*).

-Fig. 1 : Apprentissage auto-supervisé +Figure 1 : Apprentissage autosupervisé
-La tâche d'apprentissage auto-supervisé peut être définie comme suit : -* Prévoir l'avenir à partir du passé. -* Prédire le masqué à partir du visible. -* Prévoir les parties occultées à partir de toutes les parties disponibles. +La tâche d'apprentissage autosupervisé peut être définie comme suit : +* prévoir l'avenir à partir du passé +* prédire le masqué à partir du visible +* prévoir les parties occultées à partir de toutes les parties disponibles Par exemple, si un système est entraîné à prédire l'image suivante lorsque la caméra est déplacée, le système apprendra implicitement la profondeur et la parallaxe. Cela obligera le système à apprendre que les objets occultés de sa vision ne disparaissent pas mais continuent d'exister ainsi que la distinction entre les objets animés, inanimés et l'arrière-plan. Il peut également finir par apprendre la physique intuitive comme la gravité. -Les systèmes de NLP de pointe (BERT) sont pré-entraînés via un réseau neuronal géant de SSL. Vous supprimez certains mots d'une phrase et faites en sorte que le système prédisent les mots manquants. Cette méthode a été couronnée de succès. Des idées similaires ont également été expérimentées dans le domaine de la vision par ordinateur. Comme le montre l'image ci-dessous, vous pouvez prendre une image et en supprimer une partie, puis entraîner le modèle à prédire la partie manquante. +Les systèmes de NLP de pointe sont pré-entraînés via des réseaux neuronaux géants de SSL. Vous supprimez certains mots d'une phrase et faites en sorte que le système prédisent les mots manquants. Cette méthode (BERT) a été couronnée de succès. Des idées similaires ont également été expérimentées dans le domaine de la vision par ordinateur. Comme le montre l'image ci-dessous, vous pouvez prendre une image et en supprimer une partie, puis entraîner le modèle à prédire la partie manquante.

-Figure 2 : Résultats correspondants dans la vision par ordinateur +Figure 2 : Résultats correspondants dans la vision par ordinateur
Bien que les modèles puissent combler l'espace manquant, ils n'ont pas connu le même succès que les applications en NLP. Si vous deviez prendre les représentations internes générées par ces modèles, en entrée d'un système de vision par ordinateur, celui-ci est incapable de battre un modèle qui a été pré-entraîné de manière supervisée sur ImageNet. La différence ici est que le NLP est discrèt alors que les images sont continues. La différence de succès est que dans le domaine discret, nous savons comment représenter l'incertitude, nous pouvons utiliser un grand softmax sur les sorties possibles, dans le domaine continu nous ne le faisons pas. -Un système intelligent (AI agent) doit être capable de prédire les résultats de sa propre action sur l'environnement et de prendre lui-même des décisions intelligentes. Comme le monde n'est pas complètement déterministe et qu'il n'y a pas assez de puissance de calcul dans une machine/un cerveau humain pour prendre en compte toutes les possibilités, nous devons apprendre aux systèmes d'IA à prédire en présence d'incertitude dans les espaces de grande dimension. Les EBM peuvent être extrêmement utiles à cet effet. +Un système intelligent doit être capable de prédire les résultats de sa propre action sur l'environnement et de prendre lui-même des décisions intelligentes. Comme le monde n'est pas complètement déterministe et qu'il n'y a pas assez de puissance de calcul dans une machine/un cerveau humain pour prendre en compte toutes les possibilités, nous devons apprendre aux systèmes d'IA à prédire en présence d'incertitude dans les espaces en grandes dimensions. Les EBMs peuvent être extrêmement utiles à cet effet. Un réseau neuronal entraîné à l'utilisation des moindres carrés pour prédire la prochaine image d'une vidéo produira des images floues parce que le modèle ne peut pas prédire exactement l'avenir, il apprend donc à faire la moyenne de toutes les possibilités de la prochaine image à partir des données d’entraînement pour réduire la perte. @@ -83,17 +83,17 @@ Scalar-valued energy function can take two versions: 2. Unconditional $F(y)$ - measure the compatibility between the components of $y$ --> -### Les EMB à variable latente comme solution pour faire des prédictions pour l’image suivante : +### Les EMBs à variable latente comme solution pour faire des prédictions d'une image suivante -Contrairement à la régression linéaire, les EMB à variable latente prennent ce que nous savons du monde ainsi qu'une variable latente qui nous donne des informations sur ce qui s'est passé dans la réalité. Une combinaison de ces deux éléments d'information peut être utilisée pour faire une prédiction qui sera proche de ce qui se passe réellement. +Contrairement à la régression linéaire, les EMBs à variable latente prennent ce que nous savons du monde ainsi qu'une variable latente qui nous donne des informations sur ce qui s'est passé dans la réalité. Une combinaison de ces deux éléments d'information peut être utilisée pour faire une prédiction qui sera proche de ce qui se passe réellement. Ces modèles peuvent être considérés comme des systèmes qui évaluent la compatibilité entre l'entrée $x$ et la sortie réelle $y$ en fonction de la prédiction utilisant la variable latente qui minimise l'énergie du système. Vous observez l'entrée $x$ et produisez des prédictions possibles $\bar{y}$ pour différentes combinaisons de l'entrée $x$ et des variables latentes $z$ et choisissez celle qui minimise l'énergie, l'erreur de prédiction, du système. En fonction de la variable latente que nous tirons, nous pouvons nous retrouver avec toutes les prédictions possibles. La variable latente peut être considérée comme une information importante sur la sortie $y$ qui n'est pas présente dans l'entrée $x$. -La fonction énergie à valeur scalaire peut prendre deux versions : -1. Conditionnelle $F(x, y)$ - mesure de la compatibilité entre $x$ et $y$ -2. Inconditionnel $F(y)$ - mesure de la compatibilité entre les composantes de $y$ +La fonction d'énergie à valeur scalaire peut prendre deux versions : +1. conditionnelle : $F(x, y)$ mesure de la compatibilité entre $x$ et $y$ +2. inconditionnel : $F(y)$ mesure de la compatibilité entre les composantes de $y$ -## Méthodes contrastives +## Les méthodes contrastives Selon Yann, tout le monde utilisera un jour des méthodes architecturales, mais pour l'instant, ce sont les méthodes contrastives qui fonctionnent pour les images. Considérons la figure ci-dessous qui nous montre quelques points de données et les contours de la surface énergétique. Idéalement, nous voulons que la surface énergétique ait la plus faible énergie sur la surface de données. Par conséquent, nous aimerions réduire l'énergie (c'est-à-dire la valeur de $F(x,y)$) autour de l'exemple d’entraînement, mais cela peut ne pas suffire. C'est pourquoi nous l'augmentons également pour les $y$ dans la région qui devrait avoir une énergie élevée mais qui a une énergie faible.

-Fig. 6 : Méthodes contrastives +Figure 6 : Méthodes contrastives
Il y a plusieurs façons de trouver ces candidats pour lesquels nous voulons collecter de l'énergie. En voici quelques exemples : @@ -324,18 +324,18 @@ The following plot illustrates how we use the DAE. ### Auto-encodeur débruiteur (DAE) -Une façon de trouver des $y$ pour augmenter l'énergie nécessaire est de perturber aléatoirement l'exemple d’entraînement comme le montrent les flèches vertes dans le graphique ci-dessous. +Une façon de trouver des $y$ pour augmenter l'énergie nécessaire est de perturber aléatoirement l'exemple d’entraînement comme le montrent les flèches vertes dans le graphique ci-dessous :

-Fig. 7 : Carte topographique +Figure 7 : Carte topographique
-Une fois que nous avons un point de données corrompu, nous pouvons pousser l'énergie jusqu'ici. Si nous le faisons suffisamment de fois pour tous les points de données, l'échantillon d'énergie se recroquevillera autour des exemples d’entraînement. Le graphique suivant illustre la façon dont l’entraînement est effectué. +Une fois que nous avons un point de données corrompu, nous pouvons pousser l'énergie jusqu'ici. Si nous le faisons suffisamment de fois pour tous les points de données, l'échantillon d'énergie se recroquevillera autour des exemples d’entraînement. Le graphique suivant illustre la façon dont l’entraînement est effectué :

-Fig. 8 : Entraînement +Figure 8 : Entraînement
Étapes de l’entraînement: @@ -348,7 +348,7 @@ Le graphique suivant illustre la façon dont nous utilisons le DAE.

-Fig. 9 : Utilisation du DAE +Figure 9 : Utilisation du DAE
### Divergence contrastive -La divergence contrastive nous offre une façon plus intelligente de trouver le point de $y$ pour lequel nous voulons faire monter l'énergie. Nous pouvons donner un « coup de pied » aléatoire à notre point d'entraînement et ensuite descendre la fonction énergie en utilisant la descente de gradient. A la fin de la trajectoire, nous poussons l'énergie vers le haut pour le point où nous atterrissons. Ceci est illustré dans le graphique ci-dessous par la ligne verte. +La divergence contrastive nous offre une façon plus intelligente de trouver le point de $y$ pour lequel nous voulons faire monter l'énergie. Nous pouvons donner un « coup de pied » aléatoire à notre point d'entraînement et ensuite descendre la fonction d'énergie en utilisant la descente de gradient. A la fin de la trajectoire, nous poussons l'énergie vers le haut pour le point où nous atterrissons. Ceci est illustré dans le graphique ci-dessous par la ligne verte.

-Fig. 10 : Divergence contrastive +Figure 10 : Divergence contrastive
diff --git a/docs/fr/week07/07-3.md b/docs/fr/week07/07-3.md index 45fe354d8..e17b43487 100644 --- a/docs/fr/week07/07-3.md +++ b/docs/fr/week07/07-3.md @@ -29,7 +29,7 @@ Can you tell which face is fake in Fig. 1? In fact, both of them are produced by ### Génération d'images -Pouvez-vous dire quel visage est faux dans la Fig. 1 ? En fait, les deux sont produits par le générateur StyleGan2. Bien que les détails du visage soient très réalistes, l'arrière-plan semble bizarre (à gauche : flou, à droite : objets déformés). Cela s'explique par le fait que le réseau neuronal est entraîné sur des échantillons de visages. L'arrière-plan présente alors une variabilité beaucoup plus importante. Ici, le collecteur de données a environ 50 dimensions, ce qui équivaut aux degrés de liberté d'une image de visage. +Pouvez-vous dire quel visage est faux dans la figure 1 ? En fait, les deux sont produits par le générateur StyleGan2. Bien que les détails du visage soient très réalistes, l'arrière-plan semble bizarre (à gauche : flou, à droite : objets déformés). Cela s'explique par le fait que le réseau neuronal est entraîné sur des échantillons de visages. L'arrière-plan présente alors une variabilité beaucoup plus importante. Ici, la variété des données a environ 50 dimensions, ce qui équivaut aux degrés de liberté d'une image de visage.

@@ -67,21 +67,21 @@ Obviously, latent space is better at capturing the structure of an image.

-Fig. 2: Un chien et un oiseau +Figure 2 : Un chien et un oiseau
-Si nous interpolons linéairement entre l'image du chien et celle de l'oiseau (Fig. 2) dans l'espace des pixels, nous obtiendrons une superposition de deux images en fondu dans la Fig. 3. Du haut à gauche au bas à droite, le poids de l'image du chien diminue et celui de l'image de l'oiseau augmente. +Si nous interpolons linéairement entre l'image du chien et celle de l'oiseau (figure 2) dans l'espace des pixels, nous obtiendrons une superposition de deux images en fondu dans la figure 3. Du haut à gauche au bas à droite, le poids de l'image du chien diminue et celui de l'image de l'oiseau augmente.

-Fig. 3: Résultats après interpolation +Figure 3 : Résultats après interpolation
Si nous interpolons sur deux représentations de l'espace latent et les transmettons au décodeur, nous obtiendrons la transformation du chien en oiseau de la figure 4.

-Fig. 4: Résultats après alimentation du décodeur +Figure 4 : Résultats après alimentation du décodeur
De toute évidence, l'espace latent est plus efficace pour saisir la structure d'une image. @@ -126,7 +126,7 @@ De toute évidence, l'espace latent est plus efficace pour saisir la structure d " height="120px"/>
-Fig. 5: Zoom +Figure 5 : Zoom
@@ -134,20 +134,20 @@ De toute évidence, l'espace latent est plus efficace pour saisir la structure d " height="120px"/>
-Fig. 6: Décalage +Figure 6 : Décalage

-Fig. 7: Luminosité +Figure 7 : Luminosité

-Fig. 8: Rotation (Notez que la rotation peut être en 3D) +Figure 8 : Rotation (Notez que la rotation peut être en 3D)
@@ -166,12 +166,11 @@ From the output images, it is clear that there exist biases in the training data ### Image en super-résolution -Ce modèle vise à améliorer les images et à reconstruire les visages originaux. De gauche à droite sur la figure 9, la première colonne est l'image d'entrée 16x16, la deuxième est ce que vous obtiendriez avec une interpolation bicubique standard, la troisième est la sortie générée par le réseau neuronal, et à droite est la véritable image. (https://github.com/david-gpu/srez) +Ce modèle vise à améliorer les images et à reconstruire les visages originaux. De gauche à droite sur la figure 9, la première colonne est l'image d'entrée 16x16, la deuxième est ce que vous obtiendriez avec une interpolation bicubique standard, la troisième est la sortie générée par le réseau neuronal, et à droite est la véritable image.

-Fig. 9: Reconstitution des visages originaux
- +Figure 9 : Reconstitution des visages originaux D'après les images de sortie, il est clair qu'il existe des biais dans les données d’entraînement, ce qui rend les visages reconstruits inexacts. Par exemple, l'homme asiatique en haut à gauche a l'air européen dans les images de sortie en raison du déséquilibre des images d'entraînement. Le visage reconstruit des femmes en bas à gauche est bizarre en raison de l'absence d'images sous cet angle dans les données d’entraînement. @@ -199,15 +198,15 @@ Putting a grey patch on the face like in Fig. 10 makes the image away from the t

-Fig. 10: Mise en place d'une tache grise sur les visages +Figure 10 : Mise en place d'une tache grise sur les visages
-En plaçant une tache grise sur le visage, comme sur la figure 10, on éloigne l'image du collecteur d'entraînement. La reconstruction du visage de la Fig. 11 est réalisée en trouvant l'échantillon d'image le plus proche sur le collecteur d'entraînement via la minimisation de la fonction énergie. +En plaçant une tache grise sur le visage, comme sur la figure 10, on éloigne l'image de la variété d'entraînement. La reconstruction du visage de la figure 11 est réalisée en trouvant l'échantillon d'image le plus proche sur la variété d'entraînement via la minimisation de la fonction énergie.

-Fig. 11 : Image reconstruite de Fig. 10 +Figure 11 : Image reconstruite de la figure 10
@@ -228,7 +227,7 @@ The translation from text description to image in Fig. 12 is achieved by extract

-Fig. 12: Exemple de génération d’images d’après une légende +Figure 12 : Exemple de génération d’images d’après une légende
La traduction de la description textuelle en image de la figure 12 est réalisée en extrayant les représentations des caractéristiques textuelles associées à des informations visuelles importantes, puis en les décodant en images. @@ -273,10 +272,10 @@ Les auto-encodeurs sont des réseaux de neurones artificiels, entraînés de man

-Fig. 13: Architecture d'un auto-encodeur de base
+Figure 13 : Architecture d'un auto-encodeur de base
-La figure 13 montre l'architecture d'un auto-encodeur de base. Comme précédemment, nous partons du bas avec l'entrée $\boldsymbol{x}$ qui est soumise à un encodeur (transformation affine définie par $\boldsymbol{W_h}$, suivie d'un écrasement). Il en résulte la couche cachée intermédiaire $\boldsymbol{h}$. Celle-ci est soumise au décodeur (une autre transformation affine définie par $\boldsymbol{W_x}$, suivie d'un autre écrasement). Cela produit la sortie $\boldsymbol{\hat{x}}}$, qui est la prédiction/reconstruction de l'entrée par notre modèle. Selon notre convention, nous disons qu'il s'agit d'un réseau de neurones à 3 couches. +La figure 13 montre l'architecture d'un auto-encodeur de base. Comme précédemment, nous partons du bas avec l'entrée $\boldsymbol{x}$ qui est soumise à un encodeur (transformation affine définie par $\boldsymbol{W_h}$, suivie d'un écrasement). Il en résulte la couche cachée intermédiaire $\boldsymbol{h}$. Celle-ci est soumise au décodeur (une autre transformation affine définie par $\boldsymbol{W_x}$, suivie d'un autre écrasement). Cela produit la sortie $\boldsymbol{\hat{x}}$, qui est la prédiction/reconstruction de l'entrée par notre modèle. Selon notre convention, nous disons qu'il s'agit d'un réseau de neurones à 3 couches. Nous pouvons représenter mathématiquement le réseau ci-dessus en utilisant les équations suivantes : @@ -310,7 +309,7 @@ Another application of an autoencoder is as an image compressor. If we have an i À ce stade, vous vous demandez peut-être à quoi sert la prédiction de l'entrée et quelles sont les applications des auto-encodeurs. -Les principales applications d'un auto-encodeur sont la détection d'anomalies ou le débruitage d'images. Nous savons que la tâche d'un auto- encodeur est de pouvoir reconstruire des données qui vivent sur le collecteur, c'est-à-dire que si nous avons un collecteur de données, nous voudrions que notre auto-encodeur ne puisse reconstruire que l'entrée qui existe dans ce collecteur. Ainsi, nous contraignons le modèle à reconstruire les choses qui ont été observées pendant l'entraînement, et donc toute variation présente dans les nouvelles entrées sera supprimée parce que le modèle serait insensible à ce genre de perturbations. +Les principales applications d'un auto-encodeur sont la détection d'anomalies ou le débruitage d'images. Nous savons que la tâche d'un auto- encodeur est de pouvoir reconstruire des données qui vivent sur la variété, c'est-à-dire que si nous avons une variété de données, nous voudrions que notre auto-encodeur ne puisse reconstruire que l'entrée qui existe dans cette variété. Ainsi, nous contraignons le modèle à reconstruire les choses qui ont été observées pendant l'entraînement, et donc toute variation présente dans les nouvelles entrées sera supprimée parce que le modèle serait insensible à ce genre de perturbations. Une autre application de l'auto-encodeur est la compression d'images. Si nous avons une dimension intermédiaire $d$ inférieure à la dimension d'entrée $n$, alors l’encodeur peut être utilisé comme un compresseur et les représentations cachées (représentations codées) traiteraient toutes (ou la plupart) des informations de l'entrée spécifique mais prendraient moins de place. @@ -336,7 +335,7 @@ $$ $$ --> -## Reconstruction loss +## Perte de reconstruction Examinons maintenant les pertes liées à la reconstruction que nous utilisons généralement. La perte globale pour l'ensemble de données est donnée comme la perte moyenne par échantillon, c'est-à-dire @@ -373,18 +372,18 @@ Since we are trying to reconstruct the input, the model is prone to copying all It is to be noted that an under-complete layer cannot behave as an identity function simply because the hidden layer doesn't have enough dimensions to copy the input. Thus an under-complete hidden layer is less likely to overfit as compared to an over-complete hidden layer but it could still overfit. For example, given a powerful encoder and a decoder, the model could simply associate one number to each data point and learn the mapping. There are several methods to avoid overfitting such as regularization methods, architectural methods, etc. --> -## Couche cachée sous-/sur- complète +## Couche cachée sous/sur-complète Lorsque la dimensionnalité de la couche cachée $d$ est inférieure à la dimensionnalité de l'entrée $n$, on dit qu'elle est sous la couche cachée complète. Et de même, lorsque $d>n$, nous disons qu'il s'agit d'une couche cachée sur complète. La figure 14 montre une couche cachée sous-complète à gauche et une couche cachée sur-complète à droite.

-Fig. 14: Une couche cachée sous-complète vs Une couche cachée sur-complète
+Figure 14 : Une couche cachée sous-complète vs Une couche cachée sur-complète
Comme nous l'avons vu plus haut, une couche cachée sous-complète peut être utilisée pour la compression car nous encodons les informations provenant de l'entrée en moins de dimensions. En revanche, dans une couche sur-complète, nous utilisons un codage de dimension plus élevée que l'entrée. Cela facilite l'optimisation. -Comme nous essayons de reconstruire l'entrée, le modèle est enclin à copier toutes les caractéristiques d'entrée dans la couche cachée et à la faire passer comme sortie, se comportant ainsi essentiellement comme une fonction identité. Cela doit être évité car cela impliquerait que notre modèle n'apprend rien. Nous devons donc appliquer des contraintes supplémentaires en créant un goulot d'étranglement au niveau de l'information. Nous le faisons en limitant les configurations possibles que la couche cachée peut prendre aux seules configurations vues pendant l’entraînement. Cela permet une reconstruction sélective (limitée à un sous-ensemble de l'espace d'entrée) et rend le modèle insensible à tout ce qui ne se trouve pas dans le collecteur. +Comme nous essayons de reconstruire l'entrée, le modèle est enclin à copier toutes les caractéristiques d'entrée dans la couche cachée et à la faire passer comme sortie, se comportant ainsi essentiellement comme une fonction identité. Cela doit être évité car cela impliquerait que notre modèle n'apprend rien. Nous devons donc appliquer des contraintes supplémentaires en créant un goulot d'étranglement au niveau de l'information. Nous le faisons en limitant les configurations possibles que la couche cachée peut prendre aux seules configurations vues pendant l’entraînement. Cela permet une reconstruction sélective (limitée à un sous-ensemble de l'espace d'entrée) et rend le modèle insensible à tout ce qui ne se trouve pas dans la variété. Il est à noter qu'une couche sous-complète ne peut pas se comporter comme une fonction d'identité simplement parce que la couche cachée n'a pas assez de dimensions pour copier l'entrée. Ainsi, une couche cachée sous-complète a moins de chances de faire du surentraînement qu'une couche cachée sur-complète. Néanmoins elle peut quand même en faire. Par exemple, avec un encodeur et un décodeur puissants, le modèle pourrait simplement associer un numéro à chaque point de données et apprendre la cartographie. Il existe plusieurs méthodes pour éviter le surentraînement, telles que les méthodes de régularisation, les méthodes architecturales, etc. @@ -421,17 +420,17 @@ We can also use different colours to represent the distance of each input point The lighter the colour, the longer the distance a point travelled. From the diagram, we can tell that the points at the corners travelled close to 1 unit, whereas the points within the 2 branches didn't move at all since they are attracted by the top and bottom branches during the training process. --> -## Auto-encodeur de débruitage +## Auto-encodeur débruiteur -La figure 15 montre les multiples possibilités de l'auto-encodeur de débruitage et l'intuition de son fonctionnement. +La figure 15 montre les multiples possibilités de l'auto-encodeur débruiteur et l'intuition de son fonctionnement.

-Fig. 15 : Auto-encodeur de débruitage
+Figure 15 : Auto-encodeur débruiteur
Dans ce modèle, nous supposons que nous injectons la même distribution de bruit que celle que nous allons observer dans la réalité, afin que nous puissions apprendre à nous en remettre de manière robuste. -En comparant l'entrée et la sortie, nous pouvons dire que les points qui se trouvaient déjà sur les données du collecteur n'ont pas bougé, et que les points qui étaient éloignés du collecteur ont beaucoup bougé. +En comparant l'entrée et la sortie, nous pouvons dire que les points qui se trouvaient déjà sur la variété des données n'ont pas bougé et que les points qui étaient éloignés sur la variété ont beaucoup bougé. La figure 16 présente la relation entre les données d'entrée et les données de sortie. @@ -439,15 +438,15 @@ La figure 16 présente la relation entre les données d'entrée et les données
-Fig. 16: Entrée et sortie de l'auto-encodeur de débruitage
+Figure 16 : Entrée et sortie de l'auto-encodeur débruiteur
-Nous pouvons également utiliser différentes couleurs pour représenter la distance de chaque mouvement de point d'entrée, la Fig.17 montre le diagramme. +Nous pouvons également utiliser différentes couleurs pour représenter la distance de chaque mouvement de point d'entrée, la figure 17 montre le diagramme.

-Fig. 17: Mesure de la distance parcourue par les données d'entrée
+Figure 17 : Mesure de la distance parcourue par les données d'entrée
Plus la couleur est claire, plus la distance parcourue par un point est longue. D'après le diagramme, nous pouvons dire que les points aux coins ont parcouru une distance proche de 1 unité, alors que les points à l'intérieur des 2 branches n'ont pas bougé du tout puisqu'ils sont attirés par les branches supérieures et inférieures pendant le processus d’entraînement. @@ -479,11 +478,11 @@ The training manifold is a single-dimensional object going in three dimensions. ## Auto-encoder contractif -La figure 18 montre la fonction de perte de l'auto-encodeur contractif et du collecteur. +La figure 18 montre la fonction de perte de l'auto-encodeur contractif et de la variété.

-Fig. 18 : Auto-encodeur contractif
+Figure 18 : Auto-encodeur contractif
La fonction de perte contient le terme de reconstruction plus la norme au carré du gradient de la représentation cachée par rapport à l'entrée. Par conséquent, la perte globale minimisera la variation de la couche cachée compte tenu de la variation de l'entrée. L'avantage serait de rendre le modèle sensible aux directions de reconstruction tout en étant insensible aux autres directions possibles. @@ -492,10 +491,10 @@ La figure 19 montre comment ces auto-encodeurs fonctionnent en général.

-Fig. 19: Auto-encoder de base
+Figure 19 : Auto-encodeur standard
-Le collecteur d'entraînement est un objet unidimensionnel allant à trois dimensions. Où $\boldsymbol{x}\in \boldsymbol{X}\subseteq\mathbb{R}^{n}$, le but de l'auto-encodeur est d'étirer la ligne bouclée dans une direction, où $\boldsymbol{z}\in \boldsymbol{Z}\subseteq\mathbb{R}^{d}$. En conséquence, un point de la couche d'entrée sera transformé en un point de la couche latente. Nous avons maintenant la correspondance entre les points de l'espace d'entrée et les points de l'espace latent, mais pas la correspondance entre les régions de l'espace d'entrée et les régions de l'espace latent. Ensuite, nous utiliserons le décodeur pour transformer un point de la couche latente afin de générer une couche de sortie significative. +La variété d'entraînement est un objet unidimensionnel allant à trois dimensions. Où $\boldsymbol{x}\in \boldsymbol{X}\subseteq\mathbb{R}^{n}$, le but de l'auto-encodeur est d'étirer la ligne bouclée dans une direction, où $\boldsymbol{z}\in \boldsymbol{Z}\subseteq\mathbb{R}^{d}$. En conséquence, un point de la couche d'entrée sera transformé en un point de la couche latente. Nous avons maintenant la correspondance entre les points de l'espace d'entrée et les points de l'espace latent, mais pas la correspondance entre les régions de l'espace d'entrée et les régions de l'espace latent. Ensuite, nous utiliserons le décodeur pour transformer un point de la couche latente afin de générer une couche de sortie significative. ## [Notebook : Implémenter l'auto-encodeur](https://www.youtube.com/watch?v=bggWQ14DD9M&t=2491s) -Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/10-autoencoder.ipynb). +La version anglaise du *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/10-autoencoder.ipynb) et la version française [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/10-autoencoder.ipynb). -Dans ce notebook, nous allons implémenter un auto-encodeur standard et un auto-encodeur de débruitage, puis comparer les résultats. +Dans ce *notebook*, nous allons implémenter un auto-encodeur standard et un auto-encodeur débruiteur, puis comparer les résultats. -### Entraîner un auto-encodeur de débruitage +### Entraîner un auto-encodeur débruiteur -Pour l’auto-encodeur de débruitage, vous devez ajouter les étapes suivantes:
+Pour l’auto-encodeur débruiteur, vous devez ajouter les étapes suivantes:
1) Appeler `nn.Dropout()` pour éteindre les neurones de façon aléatoire.
2) Créer un masque de bruit : `do(torch.ones(img.shape))`.
3) Créez de mauvaises images en multipliant les bonnes images aux masques binaires : `img_bad = (img * noise).to(device)`. -La figure 21 montre la sortie de l'auto-encodeur de débruitage. +La figure 21 montre la sortie de l'auto-encodeur débruiteur.

-Fig. 21: Sortie de l'auto-encodeur de débruitage
+Figure 21 : Sortie de l'auto-encodeur débruiteur
@@ -698,25 +697,25 @@ Vous trouverez ci-dessous des exemples de noyaux utilisés dans l'auto-encodeur
Figure 22: Noyaux d’auto-encodeurs standards. -D'autre part, lorsque les mêmes données sont transmises à un auto-encodeur de débruitage où un masque de dropout est appliqué à chaque image avant l’application du modèle, quelque chose de différent se produit. Chaque noyau qui apprend un modèle fixe les pixels en dehors de la région où le nombre existe à une certaine valeur constante. Comme un masque de dropout est appliqué aux images, le modèle se préoccupe maintenant des pixels situés en dehors de la région où le nombre existe. +D'autre part, lorsque les mêmes données sont transmises à un auto-encodeur débruiteur où un masque de dropout est appliqué à chaque image avant l’application du modèle, quelque chose de différent se produit. Chaque noyau qui apprend un modèle fixe les pixels en dehors de la région où le nombre existe à une certaine valeur constante. Comme un masque de dropout est appliqué aux images, le modèle se préoccupe maintenant des pixels situés en dehors de la région où le nombre existe.

-Figure 23: Noyaux d’auto-encodeurs de débruitage. +Figure 23: Noyaux d’auto-encodeurs débruiteur
Par rapport à l'état de l'art, notre auto-encodeur fait en fait mieux ! Vous pouvez voir les résultats ci-dessous.

-Figure 24: Données d’entrées (MNIST). +Figure 24 : Données d’entrées (MNIST)

-Figure 25: Reconstructions de l'auto-encodeur de débruitage. +Figure 25 : Reconstructions de l'auto-encodeur débruiteur

-Figure 26: Sortie obtenue via Telea. +Figure 26 : Sortie obtenue via Telea

-Figure 27: Sortie obtenue via Navier-Stokes. +Figure 27 : Sortie obtenue via Navier-Stokes
diff --git a/docs/fr/week07/07.md b/docs/fr/week07/07.md index 7e4ca9c94..11f0708bb 100644 --- a/docs/fr/week07/07.md +++ b/docs/fr/week07/07.md @@ -13,10 +13,10 @@ We introduced the concept of the energy-based models and the intention for diffe --> -## Conférence partie A +## Cours magistral partie A -Nous introduisons le concept des modèles à base d’énergie (EBM en anglais comme abréviation de energy-based models) et l'intention d'adopter des approches différentes autres que les réseaux feed-forward. Pour résoudre la difficulté de l'inférence chez les EBM, des variables latentes sont utilisées pour fournir des informations auxiliaires et permettre de multiples prédictions. Enfin, les EBM peuvent être généraliser aux modèles probabilistes avec des fonctions de notation plus souples. +Nous introduisons le concept des modèles à base d’énergie (EBMs pour *energy-based models*) et l'intention d'adopter des approches différentes autres que les réseaux *feed-forward*. Pour résoudre la difficulté de l'inférence chez les EBMs, des variables latentes sont utilisées pour fournir des informations auxiliaires et permettre de multiples prédictions. Enfin, les EBMs peuvent être généralisés aux modèles probabilistes avec des fonctions de notation plus souples. -## Conférence partie B +## Cours magistral partie B -Nous discutons de l'apprentissage auto-supervisé, présentons la manière d’entraîné un EBM, discutons de la gestion des variables latentes, en particulier avec l’exemple des K-means. Nous présentons également les méthodes contrastives, expliquons un auto-encoders de débruitage avec une carte topographique ainsi que le processus d’entraînement et la façon dont il peut être utilisé. Nous poursuivons avec une introduction à BERT. Enfin, nous parlons de la Divergence Contrastive, également expliquée à l'aide d'une carte topographique. +Nous discutons de l'apprentissage autosupervisé, présentons la manière d’entraîné un EBM, discutons de la gestion des variables latentes, en particulier avec l’exemple des K-means. Nous présentons également les méthodes contrastives, expliquons le fonctionnement d'auto-encodeur débruiteur avec une carte topographique ainsi que le processus d’entraînement et la façon dont il peut être utilisé. Nous poursuivons avec une introduction à BERT. Enfin, nous parlons de la divergence contrastive, également expliquée à l'aide d'une carte topographique. -## Pratique +## Travaux dirigés Nous discutons de certaines applications des auto-encodeurs et des raisons pour lesquelles nous voulons les utiliser. Nous parlons ensuite des différentes architectures d'auto-encodeurs (sous ou sur une couche cachée complète), de la manière d'éviter les problèmes de surentraînement et des fonctions de perte que nous devrions utiliser. Enfin, nous mettons en place un auto-encodeur standard et un auto-encodeur débruiteur. - diff --git a/docs/fr/week08/08-1.md b/docs/fr/week08/08-1.md index 52e4f5e6c..1027edb09 100644 --- a/docs/fr/week08/08-1.md +++ b/docs/fr/week08/08-1.md @@ -26,15 +26,15 @@ Maximum Likelihood method probabilistically pushes down energies at training dat ## [Recapitulatif](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=5s) -Yann a passé les 15 premières minutes à passer en revue les modèles à base d’énergie (EBM). Veuillez-vous référer à la semaine dernière (notes de la semaine 7) pour ces informations, en particulier le concept de méthodes d'apprentissage contrastives. +Yann a passé les 15 premières minutes à passer en revue les modèles à base d’énergie (EBMs). Veuillez-vous référer aux notes de la semaine 7 pour ces informations, en particulier le concept de méthodes d'apprentissage contrastives. -Comme nous l'avons appris lors de la dernière conférence, il existe deux grandes catégories de méthodes d'apprentissage : +Comme nous l'avons vu lors du dernier cours, il existe deux grandes catégories de méthodes d'apprentissage : 1. Les méthodes contrastives qui poussent vers le bas l'énergie des points des données d’entraînement, $F(x_i, y_i)$, tout en poussant vers le haut l'énergie sur tous les autres points, $F(x_i, y')$. -2. Les méthodes architecturales qui construisent une fonction énergie$F$ qui a minimisé/limité les régions à faible énergie en appliquant une régularisation. +2. Les méthodes architecturales qui construisent une fonction d'énergie $F$ qui a minimisé/limité les régions à faible énergie en appliquant une régularisation. -Pour distinguer les caractéristiques des différentes méthodes d'entraînement, Yann a résumé 7 stratégies d'entraînement des deux classes mentionnées précédemment. L'une d'entre elles est une méthode similaire à la méthode du maximum de vraisemblance, qui pousse l'énergie des points de données vers le bas et vers le haut partout ailleurs. +Pour distinguer les caractéristiques des différentes méthodes d'entraînement, Yann a résumé sept stratégies d'entraînement des deux classes mentionnées précédemment. L'une d'entre elles est une méthode similaire à la méthode du maximum de vraisemblance, qui pousse l'énergie des points de données vers le bas et vers le haut partout ailleurs. -La méthode du maximum de vraisemblance pousse de façon probabiliste les énergies vers le bas les points des données d'entraînement et vers le haut partout ailleurs pour chaque autre valeur de $y'\neq y_i$. La méthode du maximum de vraisemblance ne se "soucie" pas des valeurs absolues des énergies, mais seulement de la différence entre les énergies. Comme la distribution des probabilités est toujours normalisée à 1, la comparaison du rapport entre deux points donnés est plus utile que la simple comparaison des valeurs absolues. +La méthode du maximum de vraisemblance pousse de façon probabiliste les énergies vers le bas les points des données d'entraînement et vers le haut partout ailleurs pour chaque autre valeur de $y'\neq y_i$. La méthode du maximum de vraisemblance ne se soucie pas des valeurs absolues des énergies, mais seulement de la différence entre les énergies. Comme la distribution des probabilités est toujours normalisée à 1, la comparaison du rapport entre deux points donnés est plus utile que la simple comparaison des valeurs absolues. -## [Méthodes contrastives en apprentissage auto-supervisé](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=613s) +## [Méthodes contrastives en apprentissage autosupervisé](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=613s) Dans les méthodes contrastives, nous poussons vers le bas l'énergie des points des données d'entraînement observés ($x_i$, $y_i$), tout en poussant vers le haut l'énergie des points en dehors de la surface des données d'entraînement. -Dans l'apprentissage auto-supervisé, nous utilisons une partie des données d'entrée pour prédire les autres parties. Nous espérons que notre modèle peut produire de bonnes caractéristiques pour la vision par ordinateur qui rivalisent avec celles des tâches supervisées. +Dans l'apprentissage autosupervisé, nous utilisons une partie des données d'entrée pour prédire les autres parties. Nous espérons que notre modèle peut produire de bonnes caractéristiques pour la vision par ordinateur qui rivalisent avec celles des tâches supervisées. -Les chercheurs ont constaté empiriquement que l'application de méthodes d’enchâssement contrastives (contrastive _embedding_ methods) à des modèles d'apprentissage auto-supervisé peut effectivement avoir de bonnes performances qui rivalisent avec celles des modèles supervisés. Nous allons explorer certaines de ces méthodes et leurs résultats ci-dessous. +Les chercheurs ont constaté empiriquement que l'application de méthodes d’enchâssement contrastives (*contrastive embedding methods*) à des modèles d'apprentissage autosupervisé peut effectivement avoir de bonnes performances qui rivalisent avec celles des modèles supervisés. Nous allons explorer certaines de ces méthodes et leurs résultats ci-dessous. -### Résultats des méthodes auto-supervisées (MoCo, PIRL, SimCLR) +### Résultats des méthodes autosupervisées (MoCo, PIRL, SimCLR)

-Figure 3 : PIRL et MoCo sur ImageNet +Figure 3 : PIRL et MoCo sur ImageNet
Comme le montre la figure ci-dessus, les méthodes MoCo et PIRL obtiennent les résultats d’état de l’art (en particulier pour les modèles de faible capacité, avec un petit nombre de paramètres). PIRL commence à se rapprocher du top 1 de la précision linéaire des baseline supervisées (~75%). -Nous pouvons mieux comprendre PIRL en examinant sa fonction objectif : NCE (Noise Contrastive Estimator) comme suit : +Nous pouvons mieux comprendre PIRL en examinant sa fonction objectif, la NCE (*Noise Contrastive Estimator*), comme suit : $$ h(v_I,v_{I^t})=\frac{\exp\big[\frac{1}{\tau}s(v_I,v_{I^t})\big]}{\exp\big[\frac{1}{\tau}s(v_I,v_{I^t})\big]+\sum_{I'\in D_{N}}\exp\big[\frac{1}{\tau}s(v_{I^t},v_{I'})\big]} @@ -162,8 +162,9 @@ Dans un mini-batch, nous aurons une paire positive (similaire) et de nombreuses Yann mentionne que pour que cela fonctionne, il faut un grand nombre d'échantillons négatifs. Dans le SGD, il peut être difficile de maintenir de façon constante un grand nombre de ces échantillons négatifs à partir de mini batchs. C'est pourquoi PIRL utilise également une banque de mémoire cache. -**Question** : Pourquoi utilisons-nous la similarité du cosinus au lieu de la norme L2 ? -Réponse : Avec une norme L2, il est très facile de rendre deux vecteurs similaires en les rendant "courts" (proches du centre) ou de rendre deux vecteurs dissemblables en les rendant très "longs" (éloignés du centre). En effet, la norme L2 n'est qu'une somme des carrés des différences partielles entre les vecteurs. Ainsi, l'utilisation de la similarité du cosinus oblige le système à trouver une bonne solution sans "tricher" en rendant les vecteurs courts ou longs. +**Pourquoi utilisons-nous la similarité du cosinus au lieu de la norme L2 ?** +> Avec une norme L2, il est très facile de rendre deux vecteurs similaires en les rendant « courts » (proches du centre) ou de rendre deux vecteurs dissemblables en les rendant très « longs » (éloignés du centre). En effet, la norme L2 n'est qu'une somme des carrés des différences partielles entre les vecteurs. Ainsi, l'utilisation de la similarité du cosinus oblige le système à trouver une bonne solution sans « tricher » en rendant les vecteurs courts ou longs. + -## [EBM à variables latentes régularisées](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=2233s) +## [EBMs à variables latentes régularisées](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=2233s) -Les modèles avec variables latentes sont capables de faire une distribution de prédictions $\overline{y}$ conditionnée par une entrée observée $x$ et une *variable latente* supplémentaire $z$. Les modèles à base d’énergie peuvent également contenir des variables latentes : +Les modèles avec variables latentes sont capables de faire une distribution de prédictions $\overline{y}$ conditionnée par une entrée observée $x$ et une variable latente supplémentaire $z$. Les modèles à base d’énergie peuvent également contenir des variables latentes :

-Fig. 1 : Exemple d'un EBM avec une variable latente +Figure 1 : : Exemple d'un EBM à variable latente
-Voir les notes de la conférence précédente pour plus de détails. - Malheureusement, si la variable latente $z$ a une trop grande puissance expressive dans la production de la prédiction finale $\overline{y}$, chaque sortie réelle $y$ sera parfaitement reconstruite à partir de l'entrée $x$ avec un $z$ choisi de manière appropriée. Cela signifie que la fonction d'énergie sera partout égale à 0, puisque l'énergie est optimisée à la fois sur $y$ et $z$ pendant l'inférence. Une solution naturelle consiste à limiter la capacité d'information de la variable latente $z$. Un moyen d'y parvenir est de régulariser la variable latente : @@ -90,10 +88,10 @@ The inner expression $Z(t) - \frac{1}{L}W_d^\top(W_dZ(t) - Y)$ is a gradient ste

-Figure 2 : Graphique de calcul de FISTA +Figure 2 : Grpahe de calcul de FISTA
-FISTA (fast ISTA) est un algorithme qui optimise la fonction d'énergie de codage épars $E(y,z)$ par rapport à $z$ en optimisant alternativement les deux termes $\Vert y - Wz\Vert^2$ et $\lambda \Vert z\Vert_{L^1}$. Nous initialisons $Z(0)$ et mettons à jour itérativement $Z$ selon la règle suivante : +FISTA (*fast ISTA*) est un algorithme qui optimise la fonction d'énergie de codage épars $E(y,z)$ par rapport à $z$ en optimisant alternativement les deux termes $\Vert y - Wz\Vert^2$ et $\lambda \Vert z\Vert_{L^1}$. Nous initialisons $Z(0)$ et mettons à jour itérativement $Z$ selon la règle suivante : $$z(t + 1) = \text{Shrinkage}_\frac{\lambda}{L}(z(t) - \frac{1}{L}W_d^\top(W_dZ(t) - y))$$ @@ -137,7 +135,7 @@ FISTA est trop coûteux pour être appliqué à des ensembles de données de gra

-Fig. 3 : EBM avec encodeur à variables latentes +Figure 3 : Encodeur d'un EBM à variables latentes
L'énergie de cette architecture comprend alors un terme supplémentaire qui mesure la différence entre la variable latente prédite $\overline z$ et la variable latente optimale $z$ : @@ -158,7 +156,7 @@ Cette règle de mise à jour peut être interprétée comme un réseau récurren

-Fig. 4 : LISTA comme un réseau récurrent déployé à travers le temps. +Figure 4 : LISTA comme un réseau récurrent déployé à travers le temps
@@ -181,7 +179,7 @@ Lorsqu'un système de codage épars avec un vecteur latent à 256 dimensions est

-Fig. 5 : Codage épars sur MNIST. Chaque image est une colonne apprise de $W$. +Figure 5 : Codage épars sur MNIST. Chaque image est une colonne apprise de $W$
Lorsqu'un système de codage épars est entraîné sur des images naturelles, les caractéristiques apprises sont les filtres de Gabor, qui sont des bords orientés. Ces caractéristiques ressemblent aux caractéristiques apprises dans les premières parties des systèmes visuels des animaux. @@ -233,12 +231,12 @@ The figure above is another example on colour images. The decoding kernel (on th

-Fig.6 Filtres et fonctions de base obtenus. Décodeur convolutionnel linéaire +Figure 6 : Filtres et fonctions de base obtenus. Décodeur convolutionnel linéaire
Les filtres de l'encodeur et du décodeur se ressemblent beaucoup. L'encodeur est simplement une convolution suivie d'une certaine non-linéarité, puis une couche diagonale pour changer l'échelle. Ensuite, il y a une faible contrainte sur le code. Le décodeur n'est qu'un décodeur linéaire convolutif et la reconstruction est ici l'erreur quadratique. -Donc, si nous imposons qu'il n'y ait qu'un seul filtre, alors il s'agit juste d'un filtre de type « center surround ». Avec deux filtres, nous pouvons obtenir des filtres de forme étrange. Avec quatre filtres, nous obtenons des bords orientés (horizontaux et verticaux) ; nous obtenons 2 polarités pour chacun des filtres. Avec huit filtres, nous pouvons obtenir des bords orientés à 8 orientations différentes. Avec 16 filtres, nous obtenons plus d'orientation ainsi que les center surround. En augmentant les filtres, on obtient des filtres plus variés, c'est-à-dire en plus des détecteurs de bords, on obtient également des détecteurs de réseaux de différentes orientations, des center surround, etc. +Donc, si nous imposons qu'il n'y ait qu'un seul filtre, alors il s'agit juste d'un filtre de type *center surround*. Avec deux filtres, nous pouvons obtenir des filtres de forme étrange. Avec quatre filtres, nous obtenons des bords orientés (horizontaux et verticaux) et 2 polarités pour chacun des filtres. Avec huit filtres, nous pouvons obtenir des bords orientés à 8 orientations différentes. Avec 16 filtres, nous obtenons plus d'orientation ainsi que les *center surround*. En augmentant les filtres, on obtient des filtres plus variés, c'est-à-dire en plus des détecteurs de bords, on obtient également des détecteurs de réseaux de différentes orientations, des *center surround*, etc. Ce phénomène semble intéressant car il est similaire à ce que nous observons dans le cortex visuel. C'est donc une indication que nous pouvons apprendre de très bonnes caractéristiques d'une manière totalement non supervisée. @@ -246,7 +244,7 @@ Par ailleurs, si nous prenons ces caractéristiques et les connectons à un rés

-Fig. 7 Codage convolutif épars sur image couleur +Figure :7 Codage convolutif épars sur image couleur
La figure ci-dessus est un autre exemple sur les images en couleur. Le noyau de décodage (sur le côté droit) est de taille 9 par 9. Ce noyau est appliqué par convolution sur l'ensemble de l'image. L'image de gauche est constituée des codes épars de l’encodeur. Le vecteur $Z$ est un espace très épars où il n'y a que peu de composantes blanches ou noires (non grises). @@ -285,7 +283,7 @@ It is also possible to adapt the size of the fuzzy balls. This is limited by a p --> ### [Auto-encodeurs variationnels](https://www.youtube.com/watch?v=ZaVP2SY23nc&t=4371s) -Les auto-encodeurs variationnels ont une architecture similaire à celle des EBM (Regularized Latent Variable), à l'exception de l’éparsité. Au contraire, le contenu informationnel du code est limité en le rendant bruyant. +Les auto-encodeurs variationnels ont une architecture similaire à celle des EBMs à variable latente régularisée, à l'exception de l’éparsité. Au contraire, le contenu informationnel du code est limité en le rendant bruyant.

Fig. 8 : Architecture de l'auto-encodeur variationnel @@ -293,15 +291,17 @@ Les auto-encodeurs variationnels ont une architecture similaire à celle des EBM La variable latente $z$ n'est pas calculée en minimisant la fonction énergie par rapport à $z$. Au lieu de cela, la fonction énergie est considérée comme un échantillonnage aléatoire de $z$ selon une distribution dont le logarithme est le coût qui la relie à ${\overline z}$. La distribution est une gaussienne avec une moyenne de ${\overline z}$ et cela se traduit par l'ajout d'un bruit gaussien à ${\overline z}$. Les vecteurs de code avec ajout de bruit gaussien peuvent être visualisés sous forme de boules floues, comme le montre la figure 9(a). -|

(a) Ensemble original de boules floues
|

(b) Mouvement de boules floues dû à la minimisation de l'énergie sans régularisation
| -
Fig. 9: Effet de la minimisation de l'énergie sur les boules floues
-Le système essaie de rendre les vecteurs de code ${\overline z}$ aussi grands que possible afin que l'effet de $z$(bruit) soit aussi petit que possible. Cela a pour résultat que les boules floues s'éloignent de l'origine comme le montre la figure 9(b). Une autre raison pour laquelle le système tente de rendre les vecteurs de code plus grands est d'éviter le chevauchement des boules floues, qui entraîne une confusion du décodeur entre les différents échantillons lors de la reconstruction. +|

(a) Ensemble original de « boules floues »
|

(b)Mouvement de « boules floues » dû à la minimisation de l'énergie sans régularisation | + +
Figure 9 : Effet de la minimisation de l'énergie sur les « boules floues »
+ +Le système essaie de rendre les vecteurs de code ${\overline z}$ aussi grands que possible afin que l'effet de $z$ (bruit) soit aussi petit que possible. Cela a pour résultat que les « boules floues » s'éloignent de l'origine comme le montre la figure 9(b). Une autre raison pour laquelle le système tente de rendre les vecteurs de code plus grands est d'éviter le chevauchement des « boules floues », qui entraîne une confusion du décodeur entre les différents échantillons lors de la reconstruction. Mais nous voulons que les boules floues se regroupent autour d'une surface de données, s'il y en a un. Ainsi, les vecteurs de code sont régularisés pour avoir une moyenne et une variance proches de zéro. Pour ce faire, nous les relions à l'origine par un ressort comme le montre la figure 10.

-Fig. 10 : Effets de la régularisation visualisés avec des ressorts +Figure 10 : Effets de la régularisation visualisés avec des ressorts
-La force du ressort détermine la proximité des boules floues par rapport à l'origine. Si le ressort est trop faible, les boules s'envoleront de l'origine. Et si le ressort est trop fort, alors elles s'effondreraient à l'origine, ce qui entraînerait une valeur énergétique élevée. Pour éviter cela, le système ne laisse les sphères se chevaucher que si les échantillons correspondants sont similaires. -Il est également possible d'adapter la taille des boules floues. Ceci est limité par une fonction de pénalité (KL Divergence) qui tente de rendre la variance proche de 1 afin que la taille de la boule ne soit ni trop grande ni trop petite pour qu'elle s'effondre. +La force du ressort détermine la proximité des « boules floues » par rapport à l'origine. Si le ressort est trop faible, les boules s'envoleront de l'origine. Et si le ressort est trop fort, alors elles s'effondreraient à l'origine, ce qui entraînerait une valeur d'énergie élevée. Pour éviter cela, le système ne laisse les sphères se chevaucher que si les échantillons correspondants sont similaires. +Il est également possible d'adapter la taille des boules floues. Ceci est limité par une fonction de pénalité (*KL Divergence*) qui tente de rendre la variance proche de 1 afin que la taille de la boule ne soit ni trop grande ni trop petite pour qu'elle s'effondre. diff --git a/docs/fr/week08/08-3.md b/docs/fr/week08/08-3.md index 26af33dee..fc7a9fc89 100644 --- a/docs/fr/week08/08-3.md +++ b/docs/fr/week08/08-3.md @@ -23,12 +23,12 @@ To summarize at a high level, a very simple form of AE is as follows: ### [Récapitulatif : Auto-encodeur (AE)](https://www.youtube.com/watch?v=7Rb4s9wNOmc&t=155s) -Pour résumer l’AE de manière très simple : +Pour résumer l'auto-encodeur de manière très simple : - Tout d'abord, l'auto-encodeur prend une entrée et l'associe à un état caché par une transformation affine $\boldsymbol{h} = f(\boldsymbol{W}_h \boldsymbol{x} + \boldsymbol{b}_h)$, où $f$ est une fonction d'activation (par élément). C'est l'étape de **l'encodeur**. Notez que $\boldsymbol{h}$ est également appelé le **code**. - Ensuite, $\hat{\boldsymbol{x}} = g(\boldsymbol{W}_x \boldsymbol{h} + \boldsymbol{b}_x)$, où $g$ est une fonction d'activation. C'est l'étape du **décodeur**. -*Pour une explication détaillée, voir les notes de [Semaine 7]({{site.baseurl}}/fr/semaine07/07-3/).* +Pour une explication détaillée, voir les notes de [Semaine 7]({{site.baseurl}}/fr/semaine07/07-3/). -## [Mise en œuvre de l'auto-encodeur variationnel (VAE)](https://www.youtube.com/watch?v=7Rb4s9wNOmc&t=1893s) +## [Implémentation de l'auto-encodeur variationnel (VAE)](https://www.youtube.com/watch?v=7Rb4s9wNOmc&t=1893s) -Le notebook Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/11-VAE.ipynb). +La version anglaise du *notebook* Jupyter se trouve [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/11-VAE.ipynb) et celle en français [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/11-VAE.ipynb). -Dans ce notebook, nous mettons en œuvre un VAE et nous l'entraînons sur l'ensemble de données MNIST. Ensuite, nous échantillonnons $\boldsymbol{z}$ à partir d'une distribution normale et l'envoyons au décodeur pour comparer le résultat. Enfin, nous examinons comment $\boldsymbol{z}$ change dans la projection 2D. +Dans ce *notebook*, nous mettons en œuvre un VAE et nous l'entraînons sur l'ensemble de données MNIST. Ensuite, nous échantillonnons $\boldsymbol{z}$ à partir d'une distribution normale et l'envoyons au décodeur pour comparer le résultat. Enfin, nous examinons comment $\boldsymbol{z}$ change dans la projection 2D. -**Note:** Dans l'ensemble de données MNIST utilisé, les valeurs des pixels ont été normalisées pour se situer dans la plage $[0, 1]$. +Note : dans le jeu de données MNIST utilisé, les valeurs des pixels ont été normalisées pour se situer dans la plage $[0, 1]$. ### Projection des moyennes -Enfin, examinons comment l'espace latent change pendant ou après l'entraînement. Les graphiques suivants de la *Figure 8* sont les moyennes issues de la sortie de l'encodeur, projetées sur l'espace 2D, où chaque couleur représente un chiffre. Nous pouvons voir qu'à partir de l'époque 0, les classes se répandent partout, avec une faible concentration. Au fur et à mesure que le modèle est entraîné, l'espace latent devient plus défini et les classes (chiffres) commencent à former des groupes. +Enfin, examinons comment l'espace latent change pendant ou après l'entraînement. Les graphiques de la figure 8 sont les moyennes issues de la sortie de l'encodeur, projetées sur l'espace 2D, où chaque couleur représente un chiffre. Nous pouvons voir qu'à partir de l'époque 0, les classes se répandent partout, avec une faible concentration. Au fur et à mesure que le modèle est entraîné, l'espace latent devient plus défini et les classes (chiffres) commencent à former des groupes.

-Fig. 8 : Projection 2D des moyennes $\E(\vect{z})$ dans l'espace latent +Figure 8 : Projection 2D des moyennes $\E(\vect{z})$ dans l'espace latent
diff --git a/docs/fr/week08/08.md b/docs/fr/week08/08.md index 28dadf67b..bcd015564 100644 --- a/docs/fr/week08/08.md +++ b/docs/fr/week08/08.md @@ -13,9 +13,9 @@ In this section, we focused on the introduction of contrastive methods in Energy --> -## Conférence partie A +## Cours magistral partie A -Dans cette section, nous nous focalisons sur l'introduction des méthodes contrastives dans les modèles à base d’énergie (EBM) sous plusieurs aspects. Tout d'abord, nous discutons de l'avantage apporté par l'application des méthodes contrastives dans l'auto-apprentissage. Ensuite, nous discutons de l'architecture des auto-encodeurs débruiteur et de leur faiblesse dans les tâches de reconstruction d'images. Nous évoquons également d'autres méthodes contrastives, comme la divergence contrastive et la divergence contrastive persistante. +Dans cette section, nous nous focalisons sur l'introduction des méthodes contrastives dans les modèles à base d’énergie (EBMs) sous plusieurs aspects. Tout d'abord, nous discutons de l'avantage apporté par l'application des méthodes contrastives dans l'apprentissage autosupervisé. Ensuite, nous discutons de l'architecture des auto-encodeurs débruiteurs et de leur faiblesse dans les tâches de reconstruction d'images. Nous évoquons également d'autres méthodes contrastives, comme la divergence contrastive et la divergence contrastive persistante. -## Conférence partie B +## Cours magistral partie B -Dans cette section, nous discutons en détail des EBM à variables latentes régularisées en couvrant les concepts de versions conditionnelles et inconditionnelles de ces modèles. Nous discutons ensuite des algorithmes ISTA, FISTA et LISTA. Nous examinons des exemples de codage épars et de filtres appris d’encodeurs épars convolutifs. Enfin, nous parlons des auto-encodeurs variationnels et des concepts sous-jacents impliqués. +Dans cette section, nous discutons en détail des EBMs à variables latentes régularisées en couvrant les concepts de versions conditionnelles et inconditionnelles de ces modèles. Nous discutons ensuite des algorithmes ISTA, FISTA et LISTA. Nous examinons des exemples de codage épars et de filtres appris d’encodeurs épars convolutifs. Enfin, nous parlons des auto-encodeurs variationnels et des concepts sous-jacents impliqués. -## Pratique -Dans cette section, nous discutons d'un type spécifique de modèle génératif appelé auto-encodeurs variationnels (VAE) et comparons leurs fonctionnalités et avantages par rapport aux auto-encodeurs classiques. Nous explorons en détail la fonction objective du VAE, en comprenant comment elle impose une certaine structure dans l'espace latent. Enfin, nous mettons en œuvre et entraînons un VAE sur l'ensemble de données MNIST et l’utilisons pour générer de nouveaux échantillons. - - - +## Travaux dirigés +Dans cette section, nous discutons d'un type spécifique de modèle génératif appelé auto-encodeurs variationnels (VAE) et comparons leurs fonctionnalités et avantages par rapport aux auto-encodeurs classiques. Nous explorons en détail la fonction objectif du VAE, en comprenant comment elle impose une certaine structure dans l'espace latent. Enfin, nous mettons en œuvre et entraînons un VAE sur l'ensemble de données MNIST et l’utilisons pour générer de nouveaux échantillons. diff --git a/docs/fr/week09/09-1.md b/docs/fr/week09/09-1.md index dd2fd3718..fd412abf8 100644 --- a/docs/fr/week09/09-1.md +++ b/docs/fr/week09/09-1.md @@ -32,17 +32,17 @@ The advantage of this is by forcing the system to find representations that can ## [Auto-encodeurs discriminants récurrents épars (Discriminative recurrent sparse autoencoder : DrSAE)](https://www.youtube.com/watch?v=Pgct8PKV7iw&t=35s) -L'idée des DrSAE consiste à combiner un codage épars, ou l'auto-encodeur épars, avec un entraînement discriminant. -

-Figure 1: Réseau DrSAE
+L'idée des DrSAEs consiste à combiner un codage épars ou l'auto-encodeur épars avec un entraînement discriminant. +

+Figure 1 : Réseau DrSAE
L'encodeur, $W_e$, est similaire à celui de la méthode LISTA. La variable $X$ est passée par $W_e$, puis par une non-linéarité. Ce résultat est ensuite multiplié par une autre matrice apprise, $S$, et ajouté à $W_e$. Il est ensuite envoyé à travers une autre non-linéarité. Ce processus peut être répété un certain nombre de fois, chaque répétition constituant une couche. Nous entraînons ce réseau de neurones avec 3 critères différents : -1. $L_1$ : Appliquer le critère $L_1$ sur le vecteur d'entités $Z$ pour le rendre épars. -2. Reconstruire $X$ : Ceci est fait en utilisant une matrice de décodage qui reproduit l'entrée sur la sortie. Ceci est fait en minimisant l'erreur quadratique, indiquée par $W_d$ dans la figure 1. -3. Ajouter un troisième terme : Ce troisième terme, indiqué par $W_c$, est un simple classifieur linéaire qui tente de prédire une catégorie. +1. $L_1$ : appliquer le critère $L_1$ sur le vecteur d'entités $Z$ pour le rendre épars. +2. Reconstruire $X$ : ceci est fait en utilisant une matrice de décodage qui reproduit l'entrée sur la sortie. Ceci est fait en minimisant l'erreur quadratique, indiquée par $W_d$ dans la figure 1. +3. Ajouter un troisième terme : ce troisième terme, indiqué par $W_c$, est un simple classifieur linéaire qui tente de prédire une catégorie. Le système est entraîné à minimiser ces trois critères en même temps. @@ -62,10 +62,10 @@ Figure 2 shows an example of an auto-encoder with group sparsity. Here, instead ### Eparsité de groupe -L'idée ici est de générer des caractéristiques éparses, c’est-à-dire pas seulement des caractéristiques normales qui sont extraites par des convolutions mais de produire essentiellement des caractéristiques qui sont éparses après le pooling. +L'idée ici est de générer des caractéristiques éparses, c’est-à-dire pas seulement des caractéristiques normales qui sont extraites par des convolutions mais de produire essentiellement des caractéristiques qui sont éparses après le *pooling*.

-Figure 2: Auto-encodeur avec éparsité de groupe
+Figure 2 : Auto-encodeur avec éparsité de groupe
La figure 2 montre un exemple d'auto-encodeur avec éparsité de groupe. Ici, au lieu de la variable latente $Z$ passant par une $L_1$, elle passe essentiellement par une $L_2$ sur les groupes. Vous prenez donc la norme $L_2$ pour chaque composant dans un groupe de $Z$, et vous prenez la somme de ces normes. C'est donc ce qui est utilisé comme régularisateur, afin que nous puissions avoir une certaine éparsité dans les groupes de $Z$. Ces groupes, ou groupes de caractéristiques, ont tendance à regrouper des caractéristiques qui sont similaires les unes aux autres. @@ -91,19 +91,19 @@ Q: Does group regularization help with grouping similar features? A: The answer is unclear, work done here was done before computational power/ data was readily available. Techniques have not been brought back to the forefront. --> -## [Auto-encodeur avec éparsité de groupe : questions et précisions](https://www.youtube.com/watch?v=Pgct8PKV7iw&t=918s) -Q : Une stratégie similaire à celle utilisée dans la première diapositive avec le classifieur et le régularisateur peut-elle être appliquée pour les VAE ? -R : Ajouter du bruit et forcer l’éparsité dans un VAE sont deux moyens de réduire l'information de la variable/code latente. Empêcher l'apprentissage d'une fonction d'identité. +## [Auto-encodeur avec éparsité de groupe : questions des étudiants](https://www.youtube.com/watch?v=Pgct8PKV7iw&t=918s) -Q : Dans la diapositive "AE with Group Sparsity", qu'est-ce que $P_j$ ? -R : $p$ est un ensemble de caractéristiques. Pour un vecteur $z$, ce serait un sous-ensemble des valeurs de $z$. +**Une stratégie similaire à celle utilisée dans la première diapositive avec le classifieur et le régularisateur peut-elle être appliquée pour les VAEs ?** +> Ajouter du bruit et forcer l’éparsité dans un VAE sont deux moyens de réduire l'information de la variable/code latente. Empêcher l'apprentissage d'une fonction d'identité. -Q : *Clarification sur le pooling des caractéristiques.* -R : (Yann dessine une représentation d’un AE avec éparsité de groupe) -L’encodeur produit une variable latente $z$, qui est régularisée en utilisant la norme $L_2$ des caractéristiques mises en commun. Cette $z$ est utilisée par le décodeur pour la reconstruction de l'image. +**Dans la diapositive « *AE with Group Sparsity* », qu'est-ce que $P_j$ ?** +> $p$ est un ensemble de caractéristiques. Pour un vecteur $z$, ce serait un sous-ensemble des valeurs de $z$. -Q : La régularisation de groupe aide-t-elle à regrouper des caractéristiques similaires ? -R : La réponse n'est pas claire, le travail effectué ici a été fait avant que la puissance de calcul/les données ne soient facilement disponibles. Les techniques n'ont pas été remises au premier plan. +**Clarification sur le *pooling* des caractéristiques.** +> L’encodeur produit une variable latente $z$, qui est régularisée en utilisant la norme $L_2$ des caractéristiques mises en commun. Cette $z$ est utilisée par le décodeur pour la reconstruction de l'image. + +**La régularisation de groupe aide-t-elle à regrouper des caractéristiques similaires ?** +> La réponse n'est pas claire, le travail effectué ici a été fait avant que la puissance de calcul/les données ne soient facilement disponibles. Les techniques n'ont pas été remises au premier plan. -## [Modèles du monde pour un contrôle autonome](https://www.youtube.com/watch?v=Pgct8PKV7iw&t=2526s) +## [Modèles du monde pour le contrôle autonome](https://www.youtube.com/watch?v=Pgct8PKV7iw&t=2526s) -L'une des utilisations les plus importantes de l'apprentissage auto-supervisé est l'apprentissage de modèles du monde pour le contrôle. Lorsque les humains effectuent une tâche, ils disposent d'un modèle interne pour le fonctionnement du monde. Par exemple, nous acquérons une intuition pour la physique à l'âge de 9 mois environ, principalement par l'observation. Dans un certain sens, cela ressemble à l'apprentissage auto-supervisé ; en apprenant à prédire ce qui va se passer, nous apprenons des principes abstraits, tout comme les modèles auto-supervisés apprennent des caractéristiques latentes. Mais en allant plus loin, les modèles internes nous permettent d'agir sur le monde. Par exemple, nous pouvons utiliser notre intuition en physique et notre compréhension du fonctionnement de nos muscles pour prédire (et exécuter) comment attraper un stylo qui tombe. +L'une des utilisations les plus importantes de l'apprentissage autosupervisé est l'apprentissage de modèles du monde pour le contrôle. Lorsque les humains effectuent une tâche, ils disposent d'un modèle interne pour le fonctionnement du monde. Par exemple, nous acquérons une intuition pour la physique à l'âge de 9 mois environ, principalement par l'observation. Dans un certain sens, cela ressemble à l'apprentissage autosupervisé. En apprenant à prédire ce qui va se passer, nous apprenons des principes abstraits, tout comme les modèles autosupervisés apprennent des caractéristiques latentes. Mais en allant plus loin, les modèles internes nous permettent d'agir sur le monde. Par exemple, nous pouvons utiliser notre intuition en physique et notre compréhension du fonctionnement de nos muscles pour prédire (et exécuter) comment attraper un stylo qui tombe. -### Qu'est-ce qu'un modèle du monde (World Model) ? +### Qu'est-ce qu'un modèle du monde (*world model*) ? -Un système de renseignement autonome comprend quatre grands modules (figure 1.). Tout d'abord, le module de perception observe le monde et calcule une représentation de l'état du monde. Cette représentation est incomplète parce que : \\ +Un système de renseignement autonome comprend quatre grands modules (figure 1). Tout d'abord, le module de perception observe le monde et calcule une représentation de l'état du monde. Cette représentation est incomplète parce que : \\ 1) l'agent n'observe pas l'univers entier \\ 2) la précision des observations est limitée. \\ -Il est également intéressant de noter que dans le modèle de feed-forward, le module de perception n'est présent que pour le pas de temps initial. Deuxièmement, le module acteur (également appelé module politique) imagine une action basée sur l'état (représenté) du monde. Troisièmement, le module modèle prédit le résultat de l'action en fonction de l'état (représenté) du monde, et peut-être aussi en fonction de certaines caractéristiques latentes. Cette prédiction est transmise au pas de temps suivant en tant que supposition de l'état suivant du monde, en prenant le rôle du module de perception à partir du pas de temps initial. La figure 2 présente une démonstration détaillée de ce processus d'anticipation. Enfin, le module critique transforme cette même prédiction en un coût de réalisation de l'action proposée, *par exemple* étant donné la vitesse à laquelle je crois que le stylo tombe, si je bouge les muscles de cette manière particulière, à quel point vais-je rater la prise ? +Il est également intéressant de noter que dans le modèle *feed-forward*, le module de perception n'est présent que pour le pas de temps initial. Deuxièmement, le module acteur (également appelé module politique) imagine une action basée sur l'état (représenté) du monde. Troisièmement, le module modèle prédit le résultat de l'action en fonction de l'état (représenté) du monde, et peut-être aussi en fonction de certaines caractéristiques latentes. Cette prédiction est transmise au pas de temps suivant en tant que supposition de l'état suivant du monde, en prenant le rôle du module de perception à partir du pas de temps initial. La figure 2 présente une démonstration détaillée de ce processus d'anticipation. Enfin, le module critique transforme cette même prédiction en un coût de réalisation de l'action proposée, par exemple étant donné la vitesse à laquelle je crois que le stylo tombe, si je bouge les muscles de cette manière particulière, à quel point vais-je rater la prise ?

-Fig. 1 : L'architecture d’un modèle du monde d'une démonstration de système de renseignement autonome. +Figure 1 : L'architecture d’un modèle du monde d'une démonstration de système de renseignement autonome

-Figure 2 : Architecture du modèle. +Figure 2 : Architecture du modèle
@@ -64,9 +64,9 @@ Aside: We use the word "inference" for latent variables, and "learning" for para ## Le cadre classique -Dans le contrôle optimal classique, il n'y a pas de module acteur/politique, mais plutôt une variable d'action. Cette formulation est optimisée par une méthode classique appelée "Model Predictive Control", qui a été utilisée par la NASA dans les années 1960 pour calculer les trajectoires des fusées lorsqu'elles sont passées des ordinateurs humains (principalement des mathématiciennes noires) aux ordinateurs électroniques. Nous pouvons considérer ce système comme un RNN déroulé, et les actions comme des variables latentes, et utiliser des méthodes de rétropropagation et de gradient (ou éventuellement d'autres méthodes, comme la programmation dynamique pour un ensemble d'actions discrètes) pour déduire la séquence d'actions qui minimise la somme des coûts des pas de temps. +Dans le contrôle optimal classique, il n'y a pas de module acteur/politique, mais plutôt une variable d'action. Cette formulation est optimisée par une méthode classique appelée « *Model Predictive Control* » qui a été utilisée par la NASA dans les années 1960 pour calculer les trajectoires des fusées lorsqu'elles sont passées des ordinateurs humains (principalement des mathématiciennes noires) aux ordinateurs électroniques. Nous pouvons considérer ce système comme un RNN déroulé et les actions comme des variables latentes. On peut utiliser des méthodes de rétropropagation et de gradient (ou éventuellement d'autres méthodes, comme la programmation dynamique pour un ensemble d'actions discrètes) pour déduire la séquence d'actions qui minimise la somme des coûts des pas de temps. -Note : Nous utilisons le mot "inférence" pour les variables latentes, et "apprentissage" pour les paramètres, bien que le processus d'optimisation de ceux-ci soit généralement similaire. Une différence importante est qu'une variable latente prend une valeur spécifique pour chaque échantillon, alors que les paramètres sont partagés entre les échantillons. +Note : nous utilisons le mot « inférence » pour les variables latentes et « apprentissage » pour les paramètres, bien que le processus d'optimisation de ceux-ci soit généralement similaire. Une différence importante est qu'une variable latente prend une valeur spécifique pour chaque échantillon, alors que les paramètres sont partagés entre les échantillons. -## [Introduction aux generative adversarial networks (GANs)](https://www.youtube.com/watch?v=xYc11zyZ26M&t=57s) +## [Introduction aux réseaux génératifs antagonistes (GANs)](https://www.youtube.com/watch?v=xYc11zyZ26M&t=57s)

-Figure 1 : Architecture d’un GAN +Figure 1 : Architecture d’un GAN
-Les GAN sont un type de réseau neuronal utilisé pour l'apprentissage machine non supervisé. Ils sont composés de deux modules contradictoires : les réseaux _générateur_ et _coût_. Ces modules se font concurrence de telle sorte que le réseau _coût_ tente de filtrer les faux exemples tandis que le _générateur_ tente de tromper ce filtre en créant des exemples réalistes $\vect{\hat{x}}$. Grâce à cette compétition, le modèle apprend un générateur qui crée des données réalistes. Ces données peuvent être utilisées dans des tâches telles que les prédictions ou pour générer des images après avoir été entraîné sur un ensemble de données particulier. +Les GANs sont un type de réseau neuronal utilisé pour l'apprentissage machine non supervisé. Ils sont composés de deux modules contradictoires : les réseaux _générateur_ et _coût_. Ces modules se font concurrence de telle sorte que le réseau _coût_ tente de filtrer les faux exemples tandis que le _générateur_ tente de tromper ce filtre en créant des exemples réalistes $\vect{\hat{x}}$. Grâce à cette compétition, le modèle apprend un générateur qui crée des données réalistes. Ces données peuvent être utilisées dans des tâches telles que les prédictions ou pour générer des images après avoir été entraîné sur un ensemble de données particulier.

-Figure 2 : Cartographie d’un GAN à partir d'une variable aléatoire +Figure 2 : Association d’un GAN à partir d'une variable aléatoire
-Les GAN sont des exemples de modèles à base d’énergie (EBM). En tant que tel, le réseau _coût_ est entraîné à produire des coûts faibles pour des intrants plus proches de la distribution réelle des données, désignée par le $\vect{x}$ rose dans la figure 2. Les données provenant d'autres distributions, comme le $\vect{\hat{x}}$ bleu de la figure 2, devraient avoir un coût élevé. Une perte d'erreur quadratique moyenne (EQM) est généralement utilisée pour calculer la performance du réseau de coût. Il convient de noter que la fonction de coût produit une valeur scalaire positive dans une plage spécifiée *c’est-à-dire* $\text{cost} : \mathbb{R}^n \rightarrow \mathbb{R}^+ \cup \{0\}$). Ceci est différent d'un discriminateur classique qui utilise une classification discrète pour ses sorties. +Les GANs sont des exemples de modèles à base d’énergie (EBMs). En tant que tel, le réseau _coût_ est entraîné à produire des coûts faibles pour des intrants plus proches de la distribution réelle des données, désignée par le $\vect{x}$ rose dans la figure 2. Les données provenant d'autres distributions, comme le $\vect{\hat{x}}$ bleu de la figure 2, devraient avoir un coût élevé. Une perte d'erreur quadratique moyenne (EQM) est généralement utilisée pour calculer la performance du réseau de coût. Il convient de noter que la fonction de coût produit une valeur scalaire positive dans une plage spécifiée c’est-à-dire $\text{cost} : \mathbb{R}^n \rightarrow \mathbb{R}^+ \cup \{0\}$). Ceci est différent d'un discriminateur classique qui utilise une classification discrète pour ses sorties. Pendant ce temps, le réseau générateur ($\text{generator} : \mathcal{Z} \rightarrow \mathbb{R}^n$) est entraîné à améliorer la correspondance de la variable aléatoire $\vect{z}$ aux données réalistes générées $\vect{\hat{x}}$ pour tromper le réseau de coût. Le générateur est entraîné d’après la sortie du réseau de coût, en essayant de minimiser l'énergie de $\vect{\hat{x}}$. Nous désignons cette énergie par $C(G(\vect{z}))$, où $C(\cdot)$ est le réseau de coût et $G(\cdot)$ est le réseau du générateur. L’entraînement du réseau de coût est basée sur la minimisation de la perte MSE, tandis que l’entraînement du réseau de générateur est basée sur la minimisation du réseau de coût, en utilisant des gradients de $C(\vect{\hat{x}})$ par rapport à $\vect{\hat{x}}$. -Pour garantir que le coût élevé est attribué aux points situés à l'extérieur de la surface de données et que le coût faible est attribué aux points situés à l'intérieur de celui-ci, la fonction de perte pour le réseau de coût $\mathcal{L}\_{C}$ est de $C(x)+[m-C(G(\vect{z}))]^+$ pour une certaine marge positive $m$. Pour minimiser $\mathcal{L}\_{C}$, il faut que $C(\vect{x}) \rightarrow 0$ et $C(G(\vect{z}) \rightarrow m$. La perte pour le générateur $\mathcal{L}\_{G}$ est simplement $C(G(\vect{z}))$, ce qui encourage le générateur à s'assurer que $C(G(\vect{z}) \\N- Flèche droite 0$. Cependant, cela crée une instabilité car 0$ \leftarrow C(G(\vect{z})) \rightarrow m$. +Pour garantir que le coût élevé est attribué aux points situés à l'extérieur de la surface de données et que le coût faible est attribué aux points situés à l'intérieur de celui-ci, la fonction de perte pour le réseau de coût $\mathcal{L}\_{C}$ est de $C(x)+[m-C(G(\vect{z}))]^+$ pour une certaine marge positive $m$. Pour minimiser $\mathcal{L}\_{C}$, il faut que $C(\vect{x}) \rightarrow 0$ et $C(G(\vect{z}) \rightarrow m$. La perte pour le générateur $\mathcal{L}\_{G}$ est simplement $C(G(\vect{z}))$, ce qui encourage le générateur à s'assurer que $C(G(\vect{z})) \rightarrow 0$. Cependant, cela crée une instabilité car 0$ \leftarrow C(G(\vect{z})) \rightarrow m$. -## Conférence partie A +## Cours magistral partie A Nous discutons des auto-encodeurs discriminants récurrents épars et de l’éparsité de groupe. L'idée principale est de savoir comment combiner un codage épars avec un entraînement discriminant. Nous examinons comment structurer un réseau avec un auto-encodeur récurrent similaire à LISTA et un décodeur. Nous discutons ensuite de la manière d'utiliser la rareté des groupes pour extraire les caractéristiques invariantes. @@ -23,9 +23,9 @@ Nous discutons des auto-encodeurs discriminants récurrents épars et de l’ép In this section, we talked about the World Models for autonomous control including the neural network architecture and training schema. Then, we discussed the difference between World Models and Reinforcement Learning (RL). Finally, we studied Generative Adversarial Networks (GANs) in terms of energy-based model with the contrastive method. --> -## Conférence partie B +## Cours magistral partie B -Dans cette section, nous parlons des modèles du monde (world models) pour le contrôle autonome, y compris l'architecture du réseau neuronal et le schéma d’entraînement. Ensuite, nous discutons de la différence entre les modèles du monde et l'apprentissage par renforcement (RL). Enfin, nous étudions les Generative Adversarial Networks (GANs) en termes d’EBM avec la méthode contrastive. +Dans cette section, nous parlons des modèles du monde (*world models*) pour le contrôle autonome, y compris l'architecture du réseau neuronal et le schéma d’entraînement. Ensuite, nous discutons de la différence entre les modèles du monde et l'apprentissage par renforcement (RL). Enfin, nous étudions les* Generative Adversarial Network*s (GANs) en termes d’EBM avec la méthode contrastive. -## Pratique -Nous explorons les Generative Adversarial Networks (GANs) et la manière dont ils peuvent produire des modèles générateurs réalistes. Nous comparons ensuite les GAN avec les VAE de la semaine 8 pour mettre en évidence les principales différences entre deux réseaux. Ensuite, nous discutons de plusieurs limites des GANs. Enfin, nous examinons le code source de l'exemple « PyTorch Deep Convolutional Generative Adversarial Networks (DCGAN) ». - - - - +## Travaux dirigés +Nous explorons les GANs et la manière dont ils peuvent produire des modèles générateurs réalistes. Nous comparons ensuite les GANs avec les VAE de la semaine 8 pour mettre en évidence les principales différences entre deux réseaux. Ensuite, nous discutons de plusieurs limites des GANs. Enfin, nous examinons le code source de l'exemple « *PyTorch Deep Convolutional Generative Adversarial Networks (DCGAN)* ». diff --git a/docs/fr/week10/10-1.md b/docs/fr/week10/10-1.md index 543c3dcff..8776a5b37 100644 --- a/docs/fr/week10/10-1.md +++ b/docs/fr/week10/10-1.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.10-1 -title: Apprentissage auto-supervisé - Tâches de prétexte +title: Apprentissage autosupervisé et tâches de prétexte lecturer: Ishan Misra authors: Aniket Bhatnagar, Dhruv Goyal, Cole Smith, Nikhil Supekar date: 6 Apr 2020 @@ -50,40 +50,40 @@ This method of ImageNet pre-training and fine-tuning on downstream task gets eve ## [Succès de la supervision : le pré-entraînement](https://www.youtube.com/watch?v=0KeR6i1_56g&t=75s) -Au cours de la dernière décennie, l'une des principales recettes ayant du succès pour de nombreux problèmes de vision par ordinateur a été l'apprentissage des représentations visuelles en effectuant un apprentissage supervisé pour la classification d'ImageNet. Les représentations et les poids de modèle appris ont pu être réutilisé comme initialisation pour d'autres tâches de vision par ordinateur où un grand nombre de données labellisées pouvaient ne pas être disponibles. +Au cours de la dernière décennie, l'une des principales approches ayant du succès pour de nombreux problèmes de vision par ordinateur a été l'apprentissage des représentations visuelles en effectuant un apprentissage supervisé pour la classification d'ImageNet. Les représentations et les poids d'un modèle appris ont pu être réutilisé comme initialisation pour d'autres tâches de vision par ordinateur où un grand nombre de données étiquetées pouvaient ne pas être disponibles. -Cependant, obtenir des annotations pour un ensemble de données de l'ampleur d'ImageNet est extrêmement long et coûteux. Exemple : L'étiquetage d'ImageNet avec 14 millions d'images a pris environ 22 années humaines. +Cependant, obtenir des annotations pour un ensemble de données de l'ampleur d'ImageNet est extrêmement long et coûteux. Par exemple l'étiquetage d'ImageNet avec 14 millions d'images a pris environ 22 années humaines. -C'est pourquoi la communauté a commencé à chercher d'autres procédés d'étiquetage, comme les mots-dièse pour les images des médias sociaux, les localisations GPS ou les approches auto-supervisées où le label est une propriété de l'échantillon de données lui-même. +C'est pourquoi la communauté a commencé à chercher d'autres procédés d'étiquetage, comme les mots-dièse pour les images des médias sociaux, les localisations GPS ou les approches autosupervisées où le label est une propriété de l'échantillon de données lui-même. Mais une question importante se pose avant de chercher d'autres procédés d'étiquetage : **Combien de données étiquetées pouvons-nous obtenir ?** -- Si nous recherchons toutes les images avec une catégorie au niveau de l'objet et des annotations dans les boîtes englobantes, nous obtenons environ un million d'images. -- Maintenant, si la contrainte pour les coordonnées de la boîte englobante est assouplie, le nombre d'images disponibles passe à 14 millions (environ). +- Si nous recherchons toutes les images avec une catégorie au niveau de l'objet et des annotations dans les boîtes de délimitation, nous obtenons environ un million d'images. +- Maintenant, si la contrainte pour les coordonnées de la boîte de délimitation est assouplie, le nombre d'images disponibles passe à 14 millions (environ). - Cependant, si nous considérons toutes les images disponibles sur Internet, il y a un saut d’un facteur 5 dans la quantité de données disponibles. - Et puis, il y a les données autres que les images, qui nécessitent d'autres entrées sensorielles pour être saisies ou comprises.

-Figure 1: Variation des données disponibles selon la complexité de l'annotation +Figure 1 : Variation des données disponibles selon la complexité de l'annotation
Par conséquent, si l'on considère que l'annotation spécifique à ImageNet a pris à elle seule 22 années humaines, il est totalement impossible de mettre à l'échelle l’étiquetage de toutes les photos sur Internet ou au-delà. -**Problème des concepts rares** (*Problème de la longue queue*) +**Problème des concepts rares** (*problème de la longue queue*) En général, la distribution des labels pour les images Internet ressemble à une longue queue. C'est-à-dire que la plupart des images correspondent à très peu de labels, alors qu'il existe un grand nombre de labels pour lesquelles peu d'images sont présentes. Ainsi, pour obtenir des échantillons annotés pour les catégories vers la fin de la queue, il faut étiqueter d'énormes quantités de données en raison de la nature de la distribution des catégories.

-Figure 2: Variation de la distribution des images disponibles avec les labels +Figure 2 : Variation de la distribution des images disponibles avec les labels
**Problème des différents domaines** -Cette méthode de pré-entraînement et de mise au point d'ImageNet sur les tâches en aval devient encore plus obscure lorsque les images des tâches en aval appartiennent à un domaine complètement différent, comme l'imagerie médicale. +Cette méthode de pré-entraînement et de d'ImageNet sur les tâches en aval devient encore plus obscure lorsque les images des tâches en aval appartiennent à un domaine complètement différent, comme l'imagerie médicale. -## Qu'est-ce que l'apprentissage auto-supervisé ? +## Qu'est-ce que l'apprentissage autosupervisé ? -**Deux façons de définir l'apprentissage auto-supervisé** +**Deux façons de définir l'apprentissage autosupervisé** : - **En se basant sur la définition de l'apprentissage supervisé** c'est-à-dire que le réseau suit un apprentissage supervisé où les labels sont obtenus de manière semi-automatique, sans intervention humaine. -- **Problème de prédiction**, où une partie des données est cachée, et le reste visible. L'objectif est donc soit de prédire les données cachées, soit de prédire certaines propriétés des données cachées. +- **Problème de prédiction** où une partie des données est cachée et le reste visible. L'objectif est donc soit de prédire les données cachées, soit de prédire certaines propriétés des données cachées. -**Comment l'apprentissage auto-supervisé diffère-t-il de l'apprentissage supervisé et de l'apprentissage non supervisé ? + +**Comment l'apprentissage autosupervisé diffère-t-il de l'apprentissage supervisé et de l'apprentissage non supervisé ?** - Les tâches d'apprentissage supervisé ont des labels prédéfinis (et généralement fournis par l'homme), - L'apprentissage non supervisé ne dispose que des échantillons de données sans aucune supervision, label ou sortie correcte. -- L'apprentissage auto-supervisé tire ses labels d'une modalité concomitante pour l'échantillon de données donné ou d'une partie concomitante de l'échantillon de données lui-même. +- L'apprentissage autosupervisé tire ses labels d'une modalité concomitante pour l'échantillon de données donné ou d'une partie concomitante de l'échantillon de données lui-même. -### L'apprentissage auto-supervisé dans le traitement du langage naturel +### L'apprentissage autosupervisé dans le traitement du langage naturel -### Pourquoi un apprentissage auto-supervisé ? +### Pourquoi un apprentissage autosupervisé ? -- L'apprentissage auto-supervisé permet d'apprendre des représentations de données en observant simplement comment différentes parties des données interagissent. +- L'apprentissage autosupervisé permet d'apprendre des représentations de données en observant simplement comment différentes parties des données interagissent. - Cela permet de réduire le nombre de données annotées. - De plus, il permet de tirer parti des multiples modalités qui peuvent être associées à un seul échantillon de données. @@ -158,12 +159,12 @@ Generally, computer vision pipelines that employ self-supervised learning involv - The pretext task is the self-supervised learning task solved to learn visual representations, with the aim of using the learned representations or model weights obtained in the process, for the downstream task. --> -### Apprentissage auto-supervisé en vision par ordinateur +### Apprentissage autosupervisé en vision par ordinateur -En général, les filières de vision par ordinateur qui font appel à l'apprentissage auto-supervisé impliquent l'exécution de deux tâches, une tâche prétexte et une tâche réelle (en aval). +En général, les pipelines de vision par ordinateur qui font appel à l'apprentissage autosupervisé impliquent l'exécution de deux tâches, une tâche prétexte et une tâche réelle (en aval). - La tâche réelle (en aval) peut être tout comme une tâche de classification ou de détection, avec des échantillons de données annotés insuffisants. -- La tâche prétexte est la tâche d'apprentissage auto-supervisée résolue pour apprendre des représentations visuelles, dans le but d'utiliser les représentations apprises ou les poids de modèle obtenus dans le processus, pour la tâche en aval. +- La tâche prétexte est la tâche d'apprentissage autosupervisée résolue pour apprendre des représentations visuelles, dans le but d'utiliser les représentations apprises ou les poids de modèle obtenus dans le processus, pour la tâche en aval. -#### Prévoir la rotation des images +#### Prédire la rotation des images - La prévision des rotations est l'une des tâches prétextes les plus populaires, qui a une architecture simple et directe et nécessite un échantillonnage minimal. - Nous appliquons des rotations de 0, 90, 180, 270 degrés à l'image et nous envoyons ces images tournées au réseau pour prédire quel type de rotation a été appliqué à l'image et le réseau effectue simplement une classification à 4 voies pour prédire la rotation. @@ -256,7 +257,7 @@ La tâche de position relative permet de trouver des zones d'image très similai

-Figure 5: Rotations de l'image +Figure 5 : Rotations de l'image
-#### Mélanger et apprendre (Shuffle & Learn) +#### Mélanger et apprendre (*Shuffle & Learn*)

-Figure 7: Interpolation +Figure 7 : Interpolation
Lorsque nous avons plusieurs images, nous en extrayons trois et si elles sont extraites dans le bon ordre, nous les qualifions de positives. Dans le cas où elles sont mélangées, nous les qualifions de négatives. Cela devient alors un problème de classification binaire pour prédire si les trames sont dans le bon ordre ou non. Ainsi, en donnant un point de départ et un point d'arrivée, nous vérifions si le milieu est une interpolation valide des deux.

-Figure 8: Architecture “Shuffle & Learn” +Figure 8 : Architecture Shuffle & Learn
Nous pouvons utiliser un réseau siamois en triplet, où les trois trames sont transmises indépendamment, puis nous concaténons les caractéristiques générées et effectuons la classification binaire pour prédire si les trames sont mélangées ou non.

-Figure 9: Représentation des voisins les plus proches +Figure 9 : Représentation des voisins les plus proches
Là encore, nous pouvons utiliser l'algorithme des plus proches voisins pour visualiser ce que nos réseaux apprennent. Dans la figure 9 ci-dessus, nous avons d'abord un cadre d'interrogation que nous alimentons pour obtenir une représentation des caractéristiques, puis nous regardons les voisins les plus proches dans l'espace de représentation. En comparant, nous pouvons observer une différence marquée entre les voisins obtenus à partir d'ImageNet, de Shuffle & Learn et de Random. ImageNet est capable de réduire l'ensemble de la sémantique, car il pourrait comprendre qu'il s'agit d'une scène de gymnastique pour la première entrée. De même, il pourrait comprendre qu'il s'agit d'une scène de plein air avec de l'herbe, etc… pour la deuxième requête. En revanche, lorsque nous observons Random, nous pouvons voir qu'il accorde une grande importance à la couleur de l'arrière-plan. -En observant Shuffle & Learn, il n'est pas immédiatement possible de savoir s'il se concentre sur la couleur ou sur le concept sémantique. Après une inspection plus poussée et l'observation de divers exemples, on a constaté qu'il s'agit de la pose de la personne. Par exemple, dans la première image, la personne est à l'envers et dans la seconde, les pieds sont dans une position particulière similaire à celle du cadre de la requête, ignorant la couleur de la scène ou de l'arrière-plan. Le raisonnement est que notre tâche de prétexte était de prédire si les images sont dans le bon ordre ou non, et pour ce faire, le réseau doit se concentrer sur ce qui bouge dans la scène, dans ce cas, la personne. +En observant *Shuffle & Learn*, il n'est pas immédiatement possible de savoir s'il se concentre sur la couleur ou sur le concept sémantique. Après une inspection plus poussée et l'observation de divers exemples, on a constaté qu'il s'agit de la pose de la personne. Par exemple, dans la première image, la personne est à l'envers et dans la seconde, les pieds sont dans une position particulière similaire à celle du cadre de la requête, ignorant la couleur de la scène ou de l'arrière-plan. Le raisonnement est que notre tâche de prétexte était de prédire si les images sont dans le bon ordre ou non, et pour ce faire, le réseau doit se concentrer sur ce qui bouge dans la scène, dans ce cas, la personne. Cela a été vérifié quantitativement en ajustant cette représentation à la tâche d'estimation des points clés humains, où, étant donné une image humaine, nous prédisons où se trouvent certains points clés comme le nez, l'épaule gauche, l'épaule droite, le coude gauche, le coude droit, etc. Cette méthode est utile pour le suivi et l'estimation de la pose.

-Figure 10: Point clé Comparaison des estimations +Figure 10 : Comparaison des estimations des points clés
-Dans la figure 10, nous comparons les résultats d'ImageNet supervisé et de Shuffle & Learn auto-supervisé sur des ensembles de données FLIC et MPII et nous pouvons voir que Shuffle and Learn donne de bons résultats pour l'estimation des points clés. +Dans la figure 10, nous comparons les résultats d'ImageNet supervisé et de *Shuffle & Learn* autosupervisé sur des ensembles de données FLIC et MPII et nous pouvons voir que *Shuffle & Learn* donne de bons résultats pour l'estimation des points clés. -## [Comprendre ce que la tâche "prétexte" apprend](https://www.youtube.com/watch?v=0KeR6i1_56g&t=2426s) +## [Comprendre ce que la tâche prétexte apprend](https://www.youtube.com/watch?v=0KeR6i1_56g&t=2426s) * Les tâches de prétexte doivent être **complémentaires** @@ -468,10 +469,10 @@ Il peut être utilisé pour prédire ce qui, dans l'image, pourrait produire un

-Figure 13: Comparaison de l'entraînement combiné disjoint versus la Position Relative et des tâches de prétexte de colorisation. ResNet101. (Misra) +Figure 13 : Comparaison de l'entraînement combiné disjoint vs la Position Relative et des tâches de prétexte de colorisation sur un ResNet101
- * Un seul prétexte peut ne pas être la bonne réponse pour apprendre les représentations + * Une seule prétexte peut ne pas être la bonne réponse pour apprendre les représentations * Les tâches de prétexte varient beaucoup dans ce qu'elles essaient de prévoir (difficilement) @@ -479,21 +480,21 @@ Il peut être utilisé pour prédire ce qui, dans l'image, pourrait produire un * Le masquage et le remplissage sont beaucoup plus difficiles => **meilleure représentation** * **Les méthodes contrastives** génèrent encore plus d'informations que les tâches prétexte -* **Question:** Comment entraîner de multiples tâches de pré-entraînement ? +* **Comment entraîner de multiples tâches de pré-entraînement ?** - * La sortie du prétexte dépendra de l'entrée. La dernière couche entièrement connectée du réseau peut être **intervertie** en fonction du type de lot. - * Par exemple : Un lot d'images en noir et blanc est envoyé au réseau dans lequel le modèle doit produire une image en couleur. Ensuite, la couche finale est permutée et reçoit un lot de patchs pour prédire la position relative. +> * La sortie du prétexte dépendra de l'entrée. La dernière couche entièrement connectée du réseau peut être **intervertie** en fonction du type de lot. +> * Par exemple : un lot d'images en noir et blanc est envoyé au réseau dans lequel le modèle doit produire une image en couleur. Ensuite, la couche finale est permutée et reçoit un lot de patchs pour prédire la position relative. -* **Question:** En quelle quantité devons-nous entraîner une tâche prétexte ? +* **En quelle quantité devons-nous entraîner une tâche prétexte ?** - * Règle empirique : avoir une tâche de prétexte très difficile telle qu'elle améliore la tâche en aval. - * En pratique, la tâche de prétexte est entraînée et ne peut pas être réentraînée. En développement, elle est entraînée dans le cadre de l'ensemble de la filière. +> * Règle empirique : avoir une tâche de prétexte très difficile telle qu'elle améliore la tâche en aval. +> * En pratique, la tâche de prétexte est entraînée et ne peut pas être réentraînée. En développement, elle est entraînée dans le cadre de l'ensemble du pipeline. -## Mise à l'échelle de l'apprentissage auto-supervisé +## Mise à l'échelle de l'apprentissage autosupervisé -### Évaluation : Fine-tuning *vs.* Classifieur linéaire +### Évaluation : Fine-tuning *vs* Classifieur linéaire Cette forme d'évaluation est une sorte de **transfert d'apprentissage**. -* **Fine Tuning** : nous utilisons l'ensemble de notre réseau comme **initialisation** pour laquelle nous entraînons un nouveau, en mettant à jour tous les poids. -* **Linear Classifier** : En plus de notre réseau prétexte, nous entraînons un petit classifieur linéaire pour effectuer notre tâche en aval, en laissant le reste du réseau intact. +* ***Finetuning*** : nous utilisons l'ensemble de notre réseau comme **initialisation** pour laquelle nous entraînons un nouveau, en mettant à jour tous les poids. +* **Classifieur linéaire** : en plus de notre réseau prétexte, nous entraînons un petit classifieur linéaire pour effectuer notre tâche en aval, en laissant le reste du réseau intact. -> Une bonne représentation doit être transférée avec un **petit entraînement**. +Une bonne représentation doit être transférée avec un **petit entraînement**. * Il est utile d'évaluer l'apprentissage du prétexte sur une **multitude de tâches différentes**. Nous pouvons le faire en extrayant la représentation créée par les différentes couches du réseau en tant que **fonctionnalités fixes** et en évaluant leur utilité à travers ces différentes tâches. - * Mesure : Précision moyenne (Mean Average Precision en anglais souvent siglée en mAP) => Précision moyenne de l'ensemble des différentes tâches que nous envisageons. - * Quelques exemples de ces tâches : Détection d'objets (en utilisant du fine-tuning), estimation de la normale de surface (voir l'ensemble de données NYU-v2) + * Mesure : la précision moyenne (*Mean Average Precision* en anglais souvent siglée en mAP) de l'ensemble des différentes tâches que nous envisageons. + * Quelques exemples de ces tâches : détection d'objets (en utilisant du *finetuning*), estimation de la surface (voir le jeu de données NYU-v2) * Qu'apprend chaque couche ? * En général, plus les couches sont profondes, plus la précision moyenne sur les tâches en aval utilisant leurs représentations augmente. * Cependant, la **couche finale** verra une forte baisse de la mAP en raison de la sur-spécialisation de la couche. diff --git a/docs/fr/week10/10-2.md b/docs/fr/week10/10-2.md index b3c56149d..6dff50de4 100644 --- a/docs/fr/week10/10-2.md +++ b/docs/fr/week10/10-2.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.10-2 -title: Apprentissage auto-supervisé, ClusterFit et PIRL +title: Apprentissage autosupervisé, ClusterFit et PIRL lecturer: Ishan Misra authors: Zhonghui Hu, Yuqing Wang, Alfred Ajay Aureate Rajakumar, Param Shah date: 6 Apr 2020 @@ -32,24 +32,24 @@ Fig. 2 plots the Mean Average Precision at each layer for Linear Classifiers on
--> -### [Que manque-t-il aux tâches de "prétexte" ? L'espoir de la généralisation](https://www.youtube.com/watch?v=0KeR6i1_56g&t=3710s) +### [Que manque-t-il aux tâches de prétexte ? L'espoir de la généralisation](https://www.youtube.com/watch?v=0KeR6i1_56g&t=3710s) -La tâche de prétexte comprend généralement des étapes de pré-entraînement qui sont auto-supervisées et ensuite nous avons nos tâches de transfert qui sont souvent de classification ou de détection. Nous *espérons* que la tâche de pré-entraînement et les tâches de transfert sont "alignées", ce qui signifie que la résolution de la tâche de prétexte aidera à résoudre les tâches de transfert. Donc, beaucoup de recherches sont nécessaires pour concevoir une tâche de prétexte et la mettre en œuvre de façon optimale. +La tâche de prétexte comprend généralement des étapes de pré-entraînement qui sont autosupervisées et ensuite nous avons nos tâches de transfert qui sont souvent de classification ou de détection. Nous espérons que la tâche de pré-entraînement et les tâches de transfert sont alignées, ce qui signifie que la résolution de la tâche de prétexte aidera à résoudre les tâches de transfert. Donc, beaucoup de recherches sont nécessaires pour concevoir une tâche de prétexte et la mettre en œuvre de façon optimale. -Cependant, il est très difficile de savoir pourquoi l'exécution d'une tâche non sémantique devrait produire de bonnes caractéristiques. Par exemple, pourquoi devrions-nous nous attendre à apprendre la "sémantique" tout en résolvant quelque chose comme un puzzle ? Ou pourquoi "prédire les mots-dièse" à partir d'images devrait-il aider à apprendre un classifieur sur des tâches de transfert ? La question reste donc posée. Comment concevoir de bonnes tâches de pré-entraînement qui soient bien alignées avec les tâches de transfert ? +Cependant, il est très difficile de savoir pourquoi l'exécution d'une tâche non sémantique devrait produire de bonnes caractéristiques. Par exemple, pourquoi devrions-nous nous attendre à apprendre la « sémantique » tout en résolvant quelque chose comme un puzzle ? Ou pourquoi prédire les mots-dièse à partir d'images devrait-il aider à apprendre un classifieur sur des tâches de transfert ? La question reste donc posée. Comment concevoir de bonnes tâches de pré-entraînement qui soient bien alignées avec les tâches de transfert ? -Une façon d'évaluer ce problème est d'examiner les représentations à chaque couche (voir Fig. 1). Si les représentations de la dernière couche ne sont pas bien alignées avec la tâche de transfert, alors la tâche de pré-entraînement peut ne pas être la bonne tâche à résoudre. +Une façon d'évaluer ce problème est d'examiner les représentations à chaque couche (voir figure 1). Si les représentations de la dernière couche ne sont pas bien alignées avec la tâche de transfert, alors la tâche de pré-entraînement peut ne pas être la bonne tâche à résoudre.

Figure 1 : Représentation des éléments à chaque couche
-La Fig. 2 représente la précision moyenne à chaque couche pour les classifieurs linéaires sur VOC07 avec un pré-entraînement Jigsaw. Il est clair que la dernière couche est très spécialisée pour le problème du puzzle. +La figure 2 représente la précision moyenne à chaque couche pour les classifieurs linéaires sur VOC07 avec un pré-entraînement Jigsaw. Il est clair que la dernière couche est très spécialisée pour le problème du puzzle.

-Figure 2 : Performance de Jigsaw en fonction de chaque couche +Figure 2 : Performance de Jigsaw en fonction de chaque couche
@@ -69,19 +69,17 @@ La Fig. 2 représente la précision moyenne à chaque couche pour les classifieu Two ways to achieve the above properties are **Clustering** and **Contrastive Learning**. They have started performing much better than whatever pretext tasks that were designed so far. One method that belongs to clustering is **ClusterFit** and another falling into invariance is **PIRL**. --> -### Qu'attendons-nous des fonctionnalités pré-entraînées ? +### Qu'attendons-nous des caractéristiques pré-entraînées ? * Représenter la façon dont les images sont liées les unes aux autres * ClusterFit : améliorer la généralisation des représentations visuelles -* Être robuste aux "facteurs de nuisance" : Invariance +* Être robuste aux facteurs de nuisance, c'est à dire être invariant, par exemple à l'éclairage, l'emplacement exact des objets, la couleur. - *par exemple* emplacement exact des objets, éclairage, couleur exacte + * PIRL : apprentissage autosupervisé des représentations invariantes du prétexte - * PIRL : Apprentissage auto-supervisé des représentations invariantes du prétexte - -Deux moyens d'atteindre les propriétés ci-dessus sont le **Clustering** et l' **Apprentissage Contrastif**. Ils ont commencé à fonctionner bien mieux que les tâches prétextes qui ont été conçues jusqu'à présent. Une méthode qui appartient au clustering est **ClusterFit** et une autre qui tombe dans l'invariance est **PIRL**. +Deux moyens d'atteindre les propriétés ci-dessus sont le *clustering* et l'*apprentissage contrastif*. Ils ont commencé à fonctionner bien mieux que les tâches prétextes qui ont été conçues jusqu'à présent. Une méthode qui appartient au clustering est **ClusterFit** et une autre qui tombe dans l'invariance est **PIRL**. -## ClusterFit : Améliorer la généralisation des représentations visuelles +## ClusterFit : améliorer la généralisation des représentations visuelles Le clustering de l'espace de présentation est un moyen de voir quelles images sont liées les unes aux autres. @@ -116,14 +114,14 @@ height="75%" width="75%" />
--> -#### Cluster : Regroupement des caractéristiques +#### Cluster : regroupement des caractéristiques Nous prenons un réseau pré-entraîné et l'utilisons pour extraire un ensemble de caractéristiques d'un ensemble d'images. Le réseau peut être n'importe quel type de réseau pré-entraîné. Le clustering K-means est alors effectué sur ces caractéristiques, de sorte que chaque image appartient à un cluster, qui devient son label.

-Figure 3 : Etape du cluster +Figure 3 : Etape du cluster
@@ -146,14 +144,14 @@ height="75%" width="75%"/>
--> -#### Formation : Prévoir l'affectation des clusters +#### Formation : prévoir l'affectation des clusters Pour cette étape, nous entraînons un réseau à partir de zéro afin de prévoir les pseudo labels des images. Ces pseudo labels sont ceux que nous avons obtenus lors de la première étape par le clustering.

-Fig. 4 : Etape de prédiction +Figure 4 : Etape de prédiction
Une tâche standard de pré-entraînement et de transfert pré-entraîne d'abord un réseau et l'évalue ensuite sur des tâches en aval, comme le montre la première ligne de la figure 5. ClusterFit effectue le pré-entraînement sur un ensemble de données $D_{cf}$ pour obtenir le réseau pré-entraîné $N_{pre}$. Le pré-entraînement $N_{pre}$ est effectué sur un ensemble de données $D_{cf}$ pour générer des clusters. Nous apprenons ensuite un nouveau réseau $N_{cf}$ à partir de zéro sur ces données. Enfin, on utilise $N_{cf}$ pour toutes les tâches en aval. @@ -161,7 +159,7 @@ Une tâche standard de pré-entraînement et de transfert pré-entraîne d'abord

-Fig. 5 : Pré entraînement "standard" + transfert *vs.* Pré entraînement "standard" + ClusterFit +Figure 5 Pré-entraînement standard + transfert vs Pré-entraînement standard + ClusterFit
-## [Apprentissage auto-supervisé des représentations invariantes du prétexte (Pretext Invariant Representations - PIRL)](https://www.youtube.com/watch?v=0KeR6i1_56g&t=4748s) +## [PIRL : apprentissage autosupervisé des représentations invariantes du prétexte](https://www.youtube.com/watch?v=0KeR6i1_56g&t=4748s) -### Suivi des objets (tracking) +### Suivi des objets (*tracking*)

Fig. 11 : Suivi des objets +height="80%" width="80%"/>
Figure 11 : Suivi des objets
-En passant un tracker d'objets sur une vidéo cela vous donne un patch mobile et ce que celui-ci vous dites est que tout patch qui a été suivi par le tracker est lié au patch original. En revanche, tout patch provenant d'une autre vidéo n'est pas un patch apparenté. Cela donne donc un ensemble d'échantillons liés et non liés. Dans la figure 11(c), vous avez cette notation de distance. Ce que ce réseau essaie d'apprendre, c'est que les patchs provenant d'une même vidéo sont liés et que les patchs provenant de vidéos différentes ne sont pas liés. D'une certaine manière, il apprend automatiquement les différentes poses d'un objet. Il essaie de regrouper un cycle, vu sous différents angles de vue ou différentes poses d'un chien. +En passant un *tracker* d'objets sur une vidéo cela vous donne un patch mobile et ce que celui-ci vous dites est que tout patch qui a été suivi par le *tracker* est lié au patch original. En revanche, tout patch provenant d'une autre vidéo n'est pas un patch apparenté. Cela donne donc un ensemble d'échantillons liés et non liés. Dans la figure 11(c), vous avez cette notation de distance. Ce que ce réseau essaie d'apprendre, c'est que les patchs provenant d'une même vidéo sont liés et que les patchs provenant de vidéos différentes ne sont pas liés. D'une certaine manière, il apprend automatiquement les différentes poses d'un objet. Il essaie de regrouper un cycle, vu sous différents angles de vue ou différentes poses d'un chien. -#### Évaluation sur l'apprentissage semi-supervisé +#### Évaluation sur l'apprentissage semisupervisé -PIRL a ensuite été évalué sur une tâche d'apprentissage semi-supervisée. Là encore, il a obtenu d'assez bons résultats. En fait, il a même été meilleur que la tâche pré-texte de Jigsaw. La seule différence entre la première et la dernière rangée est que PIRL est une version invariante, alors que Jigsaw est une version covariante. +PIRL a ensuite été évalué sur une tâche d'apprentissage semisupervisée. Là encore, il a obtenu d'assez bons résultats. En fait, il a même été meilleur que la tâche pré-texte de Jigsaw. La seule différence entre la première et la dernière rangée est que PIRL est une version invariante, alors que Jigsaw est une version covariante.

Fig. 18 : Apprentissage semi-supervisé sur ImageNet +height="70%" width="70%"/>
Figure 18 : Apprentissage semisupervisé sur ImageNet
-### Invariance *vs.* performance +### Invariance *vs* performance En termes de propriété d'invariance, on pourrait, en général, affirmer que l'invariance du PIRL est plus que celle du Clustering, qui à son tour a plus d'invariance que celle des tâches de prétexte. Et de même, la performance est plus élevée pour le PIRL que pour le Clustering, qui à son tour a une performance plus élevée que les tâches de prétexte. Cela suggère que le fait de prendre plus d'invariance dans votre méthode pourrait améliorer les performances. @@ -617,7 +615,7 @@ So in general, we should try to predict more and more information and try to be 1. Il n'est pas très clair de savoir quel ensemble de données transforme la matière. Bien que Jigsaw fonctionne, on ne sait pas très bien pourquoi il fonctionne. 2. Saturation avec la taille du modèle et la taille des données. -3. Quelles sont les invariances importantes ? (On pourrait penser aux invariances qui fonctionnent pour une tâche supervisée particulière en général comme un travail futur). +3. Quelles sont les invariances importantes ? On pourrait penser aux invariances qui fonctionnent pour une tâche supervisée particulière en général comme un travail futur. Donc, en général, nous devrions essayer de prévoir de plus en plus d'informations et essayer d'être aussi invariants que possible. @@ -625,7 +623,7 @@ Donc, en général, nous devrions essayer de prévoir de plus en plus d'informat ## Some important questions asked as doubts --> -## Quelques questions importantes posées comme des doutes +## Questions des étudiants sur plusieurs sujets -### Apprentissage contrastif et batch normalisation +### L'apprentissage contrastif et la *batch normalisation* -1) Le réseau n'apprendrait-il pas une façon très triviale de séparer les négatifs des positifs si le réseau utilise la couche de batch norm (car l'information passerait alors d'un échantillon à l'autre) ? +**Le réseau n'apprendrait-il pas une façon très triviale de séparer les négatifs des positifs si le réseau utilise la couche de batch norm (car l'information passerait alors d'un échantillon à l'autre) ?** -**Rep** : *Dans PIRL, aucun phénomène de ce type n'a été observé, donc seule la batch norm habituelle a été utilisée* +> Dans PIRL, aucun phénomène de ce type n'a été observé, donc seule la batch norm habituelle a été utilisée. -2) Est-il donc acceptable d'utiliser des batch norm pour des réseaux contrastifs ? +**Est-il donc acceptable d'utiliser une normalisation par batch pour des réseaux contrastifs ?** -**Rep** : *En général, oui. Dans SimCLR, une variante de la batch norm habituelle est utilisée pour émuler une grande taille de lot. Ainsi, la batch norm avec peut-être quelques modifications pourrait être utilisée pour faciliter l'entraînement*. +> En général, oui. Dans SimCLR, une variante de la normalisation par batchhabituelle est utilisée pour émuler une grande taille de batch. Ainsi, la normalisation par batch avec peut-être quelques modifications pourrait être utilisée pour faciliter l'entraînement. -3) La batch norm fonctionne-t-elle dans le papier PIRL uniquement parce qu'elle est mise en œuvre en tant que banque de mémoire - étant donné que toutes les représentations ne sont pas prises en même temps ? (Comme les batch norm ne sont pas spécifiquement utilisées dans le document MoCo par exemple) +**La normalisation par batch fonctionne-t-elle dans le papier PIRL uniquement parce qu'elle est mise en œuvre en tant que banque de mémoire ? Etant donné que toutes les représentations ne sont pas prises en même temps** -**Rep** : *Oui. Dans PIRL, le même lot n'a pas toutes les représentations et peut-être pourquoi la batch norm fonctionne ici, ce qui pourrait ne pas être le cas pour d'autres tâches où les représentations sont toutes corrélées dans le batch* +> Oui. Dans PIRL, le même batch n'a pas toutes les représentations et est peut-être la raison pourquoi la normalisation par batch fonctionne ici. Cela pourrait ne pas être le cas pour d'autres tâches où les représentations sont toutes corrélées dans le batch. -4) Outre la banque de mémoire, existe-t-il d'autres suggestions sur la manière de procéder en cas de perte de n-paires ? Devrions-nous utiliser AlexNet ou d'autres qui n'utilisent pas la batch norm ? Ou existe-t-il un moyen de désactiver la couche de batch norm ? (Ceci est pour une tâche d'apprentissage vidéo) +**Outre la banque de mémoire, existe-t-il d'autres suggestions sur la manière de procéder en cas de perte n-paires ? Devrions-nous utiliser AlexNet qui n'utilise pas la noramlisation par batch ou existe-t-il un moyen de désactiver la couche de normalisation par batch ? Notamment dans le cadre d'une tâche d'apprentissage vidéo** -**Rep** : *Généralement, les images sont corrélées dans les vidéos, et la performance de la batch norm se dégrade lorsqu'il y a des corrélations. De plus, même la plus simple des implémentations d'AlexNet utilise en fait la batch norm. En effet, il est beaucoup plus stable lorsqu'il est entraîné avec une batch norm. Vous pourriez même utiliser un taux d'apprentissage plus élevé et vous pourriez également l'utiliser pour d'autres tâches en aval. Vous pouvez utiliser une variante de la batch norm, par exemple, la groupe norm pour les tâches d'apprentissage vidéo, car elle ne dépend pas de la taille du batch*. +> Généralement, les images sont corrélées dans les vidéos et la performance de la normalisation par batch se dégrade lorsqu'il y a des corrélations. De plus, même la plus simple des implémentations d'AlexNet utilise en fait la normalisation par batch. En effet, il est beaucoup plus stable lorsqu'il est entraîné avec. Vous pourriez même utiliser un taux d'apprentissage plus élevé et vous pourriez également l'utiliser pour d'autres tâches en aval. Vous pouvez utiliser une variante de la normalisation par batch, par exemple la normlisation apr groupe pour les tâches d'apprentissage vidéo, car elle ne dépend pas de la taille du batch. -### Conseils relatifs aux projets d'apprentissage auto-supervisés +### Conseils relatifs aux projets d'apprentissage autosupervisés -Comment faire fonctionner un modèle simple et auto-supervisé ? Comment en amorcer la mise en œuvre ? +**Comment faire fonctionner un modèle simple et autosupervisé ? Comment en amorcer la mise en œuvre ?** -**Rep** : *Il existe une certaine classe de techniques qui sont utiles pour les étapes initiales. Par exemple, vous pouvez examiner les tâches de prétexte. La rotation est une tâche très facile à mettre en œuvre. Le nombre de pièces en mouvement est en général un bon indicateur. Si vous envisagez de mettre en œuvre une méthode existante, vous devrez peut-être examiner de plus près les détails mentionnés par les auteurs, comme le taux d'apprentissage exact utilisé, la manière dont les normes de lot ont été utilisées, etc. Plus ces éléments sont nombreux, plus la mise en œuvre est difficile. Le prochain point très important à prendre en compte est l'augmentation des données. Si quelque chose fonctionne, il faut y ajouter une augmentation des données*. +> Il existe une certaine classe de techniques qui sont utiles pour les étapes initiales. Par exemple, vous pouvez examiner les tâches de prétexte. La rotation est une tâche très facile à mettre en œuvre. Le nombre de pièces en mouvement est en général un bon indicateur. Si vous envisagez de mettre en œuvre une méthode existante, vous devrez peut-être examiner de plus près les détails mentionnés par les auteurs, comme le taux d'apprentissage exact utilisé, la manière dont les normes de lot ont été utilisées, etc. Plus ces éléments sont nombreux, plus la mise en œuvre est difficile. Le prochain point très important à prendre en compte est l'augmentation des données. Si quelque chose fonctionne, il faut y ajouter une augmentation des données. -## Conférence partie A +## Cours magistral partie A -Dans cette section, nous voyons la motivation qui sous-tend l’autoapprentissage supervisé (SSL en anglais). Nous le définissons et voyons certaines de ses applications en NLP et en vision par ordinateur. Nous comprenons comment les tâches de prétexte en SSL et voyons quelques exemples de tâches de prétexte en images, vidéos et vidéos avec son. Enfin, nous essayons d'avoir une intuition derrière la représentation apprise par les tâches de prétexte. +Dans cette section, nous voyons la motivation qui sous-tend l’apprentissage autosupervisé. Nous le définissons et voyons certaines de ses applications en traitement du langage naturel et en vision par ordinateur. Nous comprenons comment les tâches de prétexte en apprentissage autosupervisé et voyons quelques exemples de tâches de prétexte en images, vidéos et vidéos avec son. Enfin, nous essayons d'avoir une intuition derrière la représentation apprise par les tâches de prétexte. -## Conférence partie B +## Cours magistral partie B -Dans cette section, nous discutons des lacunes des tâches de prétexte, nous définissons les éléments qui font une bonne caractéristique pré-entraînée, et comment nous pouvons y parvenir en utilisant le clustering et l'apprentissage contrastif. Nous en apprenons ensuite davantage sur le ClusterFit, ses étapes et ses performances. Nous nous plongeons ensuite dans un cadre simple et spécifique pour l'apprentissage contrastif, connu sous le nom de PIRL. Nous discutons de son fonctionnement ainsi que de son évaluation dans différents contextes. +Dans cette section, nous discutons des lacunes des tâches de prétexte, nous définissons les éléments qui font une bonne caractéristique pré-entraînée et comment nous pouvons y parvenir en utilisant le clustering et l'apprentissage contrastif. Nous en apprenons ensuite davantage sur le ClusterFit, ses étapes et ses performances. Nous nous plongeons ensuite dans un cadre simple et spécifique pour l'apprentissage contrastif, connu sous le nom de PIRL. Nous discutons de son fonctionnement ainsi que de son évaluation dans différents contextes. -## Pratique -Nous explorons le [Truck Backer-Upper](http://neuro.bstu.by/ai/To-dom/My_research/Papers-2.1-done/RL-sparce-reward/9/Ref/truckbackerupper.pdf) (Nguyen & Widrow, '90). +## Travaux dirigés +Nous explorons le [*Truck Backer-Upper*](http://neuro.bstu.by/ai/To-dom/My_research/Papers-2.1-done/RL-sparce-reward/9/Ref/truckbackerupper.pdf) de Nguyen & Widrow (1990). Ce problème montre comment résoudre un problème de contrôle non-linéaire en utilisant des réseaux de neurones. Nous apprenons un modèle de la cinématique d'un camion, et nous optimisons un contrôleur grâce à ce modèle appris, en constatant que le contrôleur est capable d'apprendre des comportements complexes grâce à des données purement observationnelles. - - - - - diff --git a/docs/fr/week11/11-1.md b/docs/fr/week11/11-1.md index b0a1ad707..afb3a4859 100644 --- a/docs/fr/week11/11-1.md +++ b/docs/fr/week11/11-1.md @@ -19,7 +19,7 @@ In today's lecture, we will review some important activation functions and their ## [Fonctions d'activation](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=15s) -Dans la conférence d'aujourd'hui, nous passerons en revue certaines fonctions d'activation importantes et leurs mises en œuvre dans PyTorch. Elles sont issues de divers articles affirmant que ces fonctions fonctionnent mieux pour des problèmes spécifiques. +Passons en revue certaines fonctions d'activation importantes et leurs mises en œuvre dans PyTorch. Elles sont issues de divers articles affirmant que ces fonctions fonctionnent mieux pour des problèmes spécifiques. -## [Questions/Réponses sur les fonctions d'activation](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=861s) +## [Questions des étudiants sur les fonctions d'activation](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=861s) -### L1 *vs.* L2 pour la vision par ordinateur +### L1 vs L2 pour la vision par ordinateur En faisant des prédictions quand nous avons beaucoup de $y$ différents : @@ -963,7 +951,7 @@ Il s'agit de la perte de probabilité logarithmique négative utilisée lors de Notez que, mathématiquement, l'entrée de `NLLLoss` devrait être la probabilité (log), mais PyTorch ne l'impose pas. L'effet est donc de rendre la composante désirée aussi grande que possible. -La perte non réduite (avec :attr:`reduction` réglé sur ``'none'``) peut être décrite comme : +La perte non réduite (avec :attr:`reduction` réglé sur `'none'`) peut être décrite comme : $$\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = - w_{y_n} x_{n,y_n}, \quad @@ -971,7 +959,7 @@ $$\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad où $N$ est la taille du lot. -Si la "réduction" n'est pas "none" (par défaut "mean"), alors +Si la `reduction` n'est pas à `'none'` (par défaut `'mean'`), alors : $$\ell(x, y) = \begin{cases} \sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{y_n}} l_n, & @@ -980,7 +968,7 @@ $$\ell(x, y) = \begin{cases} \text{if reduction} = \text{"sum".} \end{cases}$$ -Cette fonction de perte a un argument optionnel "poids" qui peut être transmis en utilisant un tenseur 1D qui assigne un poids à chacune des classes. Ceci est utile lorsqu'il s'agit d'un ensemble d'entraînement déséquilibré. +Cette fonction de perte a un argument optionnel `weight` qui peut être transmis en utilisant un tenseur 1D qui assigne un poids à chacune des classes. Ceci est utile lorsqu'il s'agit d'un jeu d'entraînement déséquilibré. -#### Poids & Classes déséquilibrées : +#### Poids et classes déséquilibrées : Le vecteur de poids est utile si la fréquence est différente pour chaque catégorie/classe. Par exemple, la fréquence de la grippe commune est beaucoup plus élevée que celle du cancer du poumon. Nous pouvons simplement augmenter le poids pour les catégories qui ont un petit nombre d'échantillons. @@ -1053,7 +1041,7 @@ $$\text{loss}(x, c) = -\log\left(\frac{\exp(x[c])}{\sum_j \exp(x[j])}\right) = -x[c] + \log\left(\sum_j \exp(x[j])\right)$$ -ou dans le cas où l'argument "poids" est spécifié : +ou dans le cas où l'argument `weight` est spécifié : $$\text{loss}(x, c) = w[c] \left(-x[c] + \log\left(\sum_j\exp(x[j])\right)\right)$$ @@ -1061,7 +1049,7 @@ La moyenne des pertes est calculée à partir des observations de chaque minibat Une interprétation physique de la perte d'entropie croisée est liée à la divergence de Kullback-Leibler (divergence KL), où nous mesurons la divergence entre deux distributions. Ici, les (quasi) distributions sont représentées par le vecteur x (prédictions) et la distribution cible (un vecteur one-hot avec 0 sur les mauvaises classes et 1 sur la bonne classe). -Mathématiquement, +Mathématiquement : $$H(p,q) = H(p) + \mathcal{D}_{KL} (p \mid\mid q)$$ diff --git a/docs/fr/week11/11-2.md b/docs/fr/week11/11-2.md index 15d15a621..4ed88ee70 100644 --- a/docs/fr/week11/11-2.md +++ b/docs/fr/week11/11-2.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.11-2 lecturer: Yann Le Cun -title: Fonctions de perte (continues) et fonctions de perte pour les modèles à base d’énergie (EBM) +title: Fonctions de perte (continues) et fonctions de perte pour les modèles à base d’énergie (EBMs) authors: Charles Brillo-Sonnino, Shizhan Gong, Natalie Frank, Yunan Hu date: 13 Apr 2020 translation-date: 11 Aug 2020 @@ -19,7 +19,7 @@ $$ This loss is a special case of cross entropy for when you have only two classes so it can be reduced to a simpler function. This is used for measuring the error of a reconstruction in, for example, an auto-encoder. This formula assume $x$ and $y$ are probabilities, so they are strictly between 0 and 1. --> -### [Perte d'entropie croisée binaire (Binary Cross Entropy - BCE) - `nn.BCELoss()`](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=3207s) +### [Perte d'entropie croisée binaire (Binary Cross Entropy : BCE) - `nn.BCELoss()`](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=3207s) $$ \ell(x,y) = L = \{l_1,...,l_N\}^T, \qquad l_n = -w_n[y_n\log x_n+(1-y_n)\log(1-x_n)] @@ -43,7 +43,7 @@ $$ \ell(x,y) = L = \{l_1,...,l_N\}^T, \qquad l_n = y_n(\log y_n-x_n) $$ -Il s'agit d'une fonction de perte simple pour les cas où votre cible est une distribution one-hot (*c'est-à-dire que * $y$ est une catégorie). Là encore, elle suppose que $x$ et $y$ sont des probabilités. Elle présente l'inconvénient de ne pas être fusionnée avec une softmax ou une log-softmax, ce qui peut poser des problèmes de stabilité numérique. +Il s'agit d'une fonction de perte simple pour les cas où votre cible est une distribution *one-hot* (c'est-à-dire que $y$ est une catégorie). Là encore, elle suppose que $x$ et $y$ sont des probabilités. Elle présente l'inconvénient de ne pas être fusionnée avec une softmax ou une log-softmax, ce qui peut poser des problèmes de stabilité numérique. -### BCE Loss with Logits - `nn.BCEWithLogitsLoss()` +### *BCE Loss with Logits* - `nn.BCEWithLogitsLoss()` $$ \ell(x,y) = L = \{l_1,...,l_N\}^T, \qquad l_n = -w_n[y_n\log \sigma(x_n)+(1-y_n)\log(1-\sigma(x_n))] @@ -74,13 +74,13 @@ Margin losses are an important category of losses. If you have two inputs, this --> -### Margin Ranking Loss - `nn.MarginRankingLoss()` +### Perte *Margin Ranking* - `nn.MarginRankingLoss()` $$ L(x,y) = \max(0, -y*(x_1-x_2)+\text{margin}) $$ -Les pertes de marge constituent une catégorie importante de pertes. Si vous avez deux entrées, cette fonction de perte indique que vous voulez que l'une d'elles soit plus importante que l'autre d'au moins une marge. Dans ce cas, $y$ est une variable binaire $\in \{ -1, 1\}$. Imaginez que les deux entrées soient des scores de deux catégories. Vous voulez que le score de la catégorie correcte soit plus grand que le score des catégories incorrectes d'au moins une certaine marge. Comme pour la perte hinge, si $y*(x_1-x_2)$ est supérieur à la marge, le coût est de 0. S'il est inférieur, le coût augmente de façon linéaire. Si vous deviez l'utiliser pour la classification, vous auriez $x_1$ comme score de la bonne réponse et $x_2$ comme score de la réponse incorrecte la plus élevée du mini batch. Si elle est utilisée dans des modèles basés sur l'énergie (voir plus loin), cette fonction de perte pousse vers le bas la bonne réponse $x_1$ et vers le haut la mauvaise réponse $x_2$. +Les pertes avec marge constituent une catégorie importante de pertes. Si vous avez deux entrées, cette fonction de perte indique que vous voulez que l'une d'elles soit plus importante que l'autre d'au moins une marge. Dans ce cas, $y$ est une variable binaire $\in \{ -1, 1\}$. Imaginez que les deux entrées soient des scores de deux catégories. Vous voulez que le score de la catégorie correcte soit plus grand que le score des catégories incorrectes d'au moins une certaine marge. Comme pour la perte *Hinge*, si $y*(x_1-x_2)$ est supérieur à la marge, le coût est de 0. S'il est inférieur, le coût augmente de façon linéaire. Si vous deviez l'utiliser pour la classification, vous auriez $x_1$ comme score de la bonne réponse et $x_2$ comme score de la réponse incorrecte la plus élevée du mini batch. Si elle est utilisée dans des modèles à base d'énergie (voir plus loin), cette fonction de perte pousse vers le bas la bonne réponse $x_1$ et vers le haut la mauvaise réponse $x_2$. -### Triplet Margin Loss - `nn.TripletMarginLoss()` +### Perte *Triplet Margin* - `nn.TripletMarginLoss()` $$ L(a,p,n) = \max\{d(a_i,p_i)-d(a_i,n_i)+\text{margin}, 0\} @@ -110,7 +110,7 @@ Cette perte est utilisée pour mesurer une similarité relative entre les échan

-Fig. 1 : Triplet de perte de marge +Figure 1 : Triplet de perte de marge
Elle a été utilisée à l'origine pour l'entraînement d'un système de recherche d'images pour Google. À l'époque, vous deviez taper une requête dans Google et celui-ci l'encodait dans un vecteur. Il comparait ensuite ce vecteur à un ensemble de vecteurs provenant d'images qui avaient été précédemment indexées. Google récupère alors les images qui sont les plus proches de votre vecteur. @@ -128,7 +128,7 @@ Creates a criterion that optimizes a two-class classification logistic loss betw * This loss function wants to pull the positive values of $y[i]*x[i]$ closer together and push the negative values far apart but, as opposed to a hard margin, with some continuous, exponentially decaying effect on the loss . --> -### Perte de marge douce - `nn.SoftMarginLoss()` +### Perte *SoftMargin* - `nn.SoftMarginLoss()` $$ L(x,y) = \sum_i\frac{\log(1+\exp(-y[i]*x[i]))}{x.\text{nelement()}} @@ -150,9 +150,9 @@ $$ This margin-base loss allows for different inputs to have variable amounts of targets. In this case you have several categories for which you want high scores and it sums the hinge loss over all categories. For EBMs, this loss function pushes down on desired categories and pushes up on non-desired categories. --> -### Multi-Class Hinge Loss - `nn.MultiLabelMarginLoss()` +### Perte *Multi-Class Hinge* - `nn.MultiLabelMarginLoss()` -Cette perte permet à différents intrants d'avoir des quantités variables d'objectifs. Dans ce cas, vous avez plusieurs catégories pour lesquelles vous souhaitez obtenir des scores élevés et elle additionne la perte sur toutes les catégories. Pour les EBM, cette fonction de perte pousse vers le bas les catégories souhaitées et vers le haut les catégories non souhaitées. +Cette perte permet à différents intrants d'avoir des quantités variables d'objectifs. Dans ce cas, vous avez plusieurs catégories pour lesquelles vous souhaitez obtenir des scores élevés et elle additionne la perte sur toutes les catégories. Pour les EBMs, cette fonction de perte pousse vers le bas les catégories souhaitées et vers le haut les catégories non souhaitées. -### Hinge Embedding Loss - `nn.HingeEmbeddingLoss()` +### Perte *Hinge Embedding* - `nn.HingeEmbeddingLoss()` $$ @@ -186,7 +186,7 @@ l_n = \right. $$ -Cette perte est utilisée pour l'apprentissage semi-supervisé en mesurant si deux entrées sont similaires ou dissemblables. Elle rassemble les choses qui sont similaires et repousse celles qui sont dissemblables. La variable $y$ indique si la paire de notes doit aller dans une certaine direction. En utilisant une telle perte, le score est positif si $y$ est égal à 1 et une certaine marge $\Delta$ si $y$ est égal à -1. +Cette perte est utilisée pour l'apprentissage semisupervisé en mesurant si deux entrées sont similaires ou dissemblables. Elle rassemble les choses qui sont similaires et repousse celles qui sont dissemblables. La variable $y$ indique si la paire de notes doit aller dans une certaine direction. En utilisant une telle perte, le score est positif si $y$ est égal à 1 et une certaine marge $\Delta$ si $y$ est égal à -1. -### Cosine Embedding Loss - `nn.CosineEmbeddingLoss()` +### Perte *Cosine Embedding* - `nn.CosineEmbeddingLoss()` $$ l_n = @@ -224,7 +224,7 @@ l_n = $$ -Cette perte est utilisée pour mesurer si deux entrées sont similaires ou dissemblables, en utilisant la distance cosinusoïdale, et est généralement utilisée pour l'apprentissage d’enchâssements non linéaires ou pour l'apprentissage semi-supervisé. +Cette perte est utilisée pour mesurer si deux entrées sont similaires ou dissemblables, en utilisant la distance cosinusoïdale et est généralement utilisée pour l'apprentissage d’enchâssements non linéaires ou pour l'apprentissage semisupervisé. * Pensée d'une autre manière, 1 moins le cosinus de l'angle entre les deux vecteurs est fondamentalement la distance euclidienne normalisée. * L'avantage de cette méthode est que lorsque vous avez deux vecteurs et que vous voulez rendre leur distance aussi grande que possible, il est très facile de faire en sorte que le réseau y parvienne en rendant les vecteurs très longs. Bien sûr, ce n'est pas optimal. Vous ne voulez pas que le système fabrique des vecteurs de grande taille, mais qu'il fasse tourner les vecteurs dans la bonne direction, de sorte que vous normalisiez les vecteurs et calculiez la distance euclidienne normalisée. @@ -257,19 +257,19 @@ Application Example: Speech recognition system --> -### [Connectionist Temporal Classification (CTC) Loss - `nn.CTCLoss()`](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=4103s) +### [La perte Connectionist Temporal Classification (CTC) - `nn.CTCLoss()`](https://www.youtube.com/watch?v=bj1fh3BvqSU&t=4103s) Calcule la perte entre une série chronologique continue (non segmentée) et une séquence cible. * Les sommes des pertes CTC sur la probabilité des alignements possibles de l'entrée vers la cible, produisent une valeur de perte qui est différenciable par rapport à chaque nœud d'entrée. -* L'alignement de l'entrée sur la cible est supposé être "plusieurs vers un", ce qui limite la longueur de la séquence cible de sorte qu'elle doit être inférieure ou égale à la longueur d'entrée. +* L'alignement de l'entrée sur la cible est supposé être « plusieurs vers un », ce qui limite la longueur de la séquence cible de sorte qu'elle doit être inférieure ou égale à la longueur d'entrée. * Utile lorsque votre sortie est une séquence de vecteurs, qui correspond à un grand nombre de catégories.

-Figure 2 : Perte CTC pour la reconnaissance vocale +Figure 2 : Perte CTC pour la reconnaissance vocale
-Exemple de demande : Système de reconnaissance vocale +Exemple d'un système de reconnaissance vocale : * Objectif : prédire quel mot est prononcé toutes les 10 millisecondes. * Chaque mot est représenté par une séquence de sons. * En fonction de la vitesse de la personne qui parle, des sons de différentes longueurs peuvent être associés au même mot. @@ -277,14 +277,14 @@ Exemple de demande : Système de reconnaissance vocale

-Figure 3 : Mise en place d'un système de cartographie personnalisé +Figure 3 : Configuration « plusieurs vers un »
-# Modèles à base d'énergie (EBM)(Partie IV) - Fonction de perte +# Modèles à base d'énergie (EBMs) - Fonction de perte -### Negative Log-Likelihood Loss +### Perte *Negative Log-Likelihood* $$ L_{nll}(W, S) = \frac{1}{P} \sum_{i=1}^P (E(W, Y^i, X^i) + \frac{1}{\beta} \log \int_{y \in \mathcal{Y}} e^{\beta E(W, y, X^i)}) @@ -463,7 +463,7 @@ $$ \bar Y^i=\text{argmin}_{Y\in \mathcal Y\text{ and }\|Y-Y^i\|>\epsilon} E(W,Y,X^i) $$ -Dans le cas discret, la *réponse incorrecte la plus offensante* est celle dont l'énergie est la plus faible et qui n'est pas la bonne réponse. Dans le cas continu, l'énergie pour $Y$ extrêmement proche de $Y^i$ devrait être proche de $E(W,Y^i,X^i)$. De plus, le $\text{argmin}$ évalué sur $Y$ non égal à $Y^i$ serait 0. En conséquence, nous choisissons une distance $\epsilon$ et décidons que seul $Y$ est au moins $\epsilon$ de $Y_i$ doit être considéré comme la "mauvaise réponse". C'est pourquoi l'optimisation ne porte que sur les $Y$ de distance au moins égale à $\epsilon$ de $Y^i$. +Dans le cas discret, la *réponse incorrecte la plus offensante* est celle dont l'énergie est la plus faible et qui n'est pas la bonne réponse. Dans le cas continu, l'énergie pour $Y$ extrêmement proche de $Y^i$ devrait être proche de $E(W,Y^i,X^i)$. De plus, le $\text{argmin}$ évalué sur $Y$ non égal à $Y^i$ serait 0. En conséquence, nous choisissons une distance $\epsilon$ et décidons que seul $Y$ est au moins $\epsilon$ de $Y_i$ doit être considéré comme la mauvaise réponse. C'est pourquoi l'optimisation ne porte que sur les $Y$ de distance au moins égale à $\epsilon$ de $Y^i$. Si la fonction d'énergie est capable de garantir que l'énergie de la *réponse incorrecte la plus offensante* est supérieure à l'énergie de la bonne réponse d'une certaine marge, alors cette fonction d'énergie devrait bien fonctionner. @@ -492,21 +492,20 @@ Q: How do you pick $m$? A: It's arbitrary, but it affects the weights of the last layer. --> -### Hinge Loss +### Perte *Hinge* $$ L_{\text{hinge}}(W,Y^i,X^i)=\max(0,m+E(W,Y^i,X^i))-E(W,\bar Y^i,X^i) $$ -Où $\bar Y^i$ est la *réponse incorrecte la plus offensante*. Cette perte impose que la différence entre la bonne réponse et la réponse incorrecte la plus offensante soit d'au moins $m$. +où $\bar Y^i$ est la *réponse incorrecte la plus offensante*. Cette perte impose que la différence entre la bonne réponse et la réponse incorrecte la plus offensante soit d'au moins $m$.

-Fig. 4 : Hinge Loss
- -Q : Comment choisir $m$? +Figure 4 : Perte Hinge -R : C'est arbitraire, mais cela affecte les poids de la dernière couche. +**Comment choisir $m$?** +> C'est arbitraire, mais cela affecte les poids de la dernière couche. -### Log Loss +### *Log Loss* $$ L_{\log}(W,Y^i,X^i)=\log(1+e^{E(W,Y^i,X^i)-E(W,\bar Y^i,X^i)}) $$ -On peut considérer cela comme une Hinge Loss "douce. Cette perte tente d'imposer une "marge infinie", mais en raison de la décroissance exponentielle de la pente, elle ne se produit pas. +On peut considérer cela comme une Hinge Loss douce. Cette perte tente d'imposer une marge infinie, mais en raison de la décroissance exponentielle de la pente, elle ne se produit pas.

-Fig. 5: Log Loss +Figure 5 : Log Loss
@@ -547,7 +546,7 @@ $$ This loss combines the square of the energy with a square hinge. The combination tries to minimize the energy and but enforce margin at least $m$ on the most offending incorrect answer. This is very similar to the loss used in Siamese nets. --> -### Square-Square Loss +### *Square-Square Loss* $$ L_{sq-sq}(W,Y^i,X^i)=E(W,Y^i,X^i)^2+(\max(0,m-E(W,\bar Y^i,X^i)))^2 @@ -585,11 +584,13 @@ We assume that $Y$ is discrete, but if it were continuous, the sum would be repl Il y en a tout un tas. Voici un résumé de bonnes et mauvaises fonctions de perte.

-Fig. 6 : Sélection des fonctions de perte d’EBM +Figure 6 : Sélection des fonctions de perte d’EBM
-La colonne de droite indique si la fonction énergie impose une marge. La simple perte d'énergie ne pousse nulle part, donc elle n'a pas de marge. La perte d'énergie ne fonctionne pas pour tous les problèmes. La perte de perceptron fonctionne si vous avez une paramétrisation linéaire de votre énergie mais pas en général. Certaines ont une marge finie comme la perte de la charnière, et d'autres une marge infinie comme la charnière souple. -Q : Comment la réponse incorrecte la plus offensante se trouve-t-elle dans le cas continu ? -R : Vous voulez pousser sur un point qui est suffisamment éloigné de $Y^i$, car s'il est trop proche, les paramètres peuvent ne pas bouger beaucoup puisque la fonction définie par un réseau neuronal est "raide". Mais en général, c'est difficile et c'est le problème que les méthodes de sélection d'échantillons contrastifs tentent de résoudre. Il n'y a pas une seule façon correcte de le faire. + +La colonne de droite indique si la fonction d'énergie impose une marge. La simple perte d'énergie ne pousse nulle part, donc elle n'a pas de marge. La perte d'énergie ne fonctionne pas pour tous les problèmes. La perte de perceptron fonctionne si vous avez une paramétrisation linéaire de votre énergie mais pas en général. Certaines ont une marge finie comme la perte de la charnière et d'autres une marge infinie comme la charnière souple. + +**Comment la réponse incorrecte la plus offensante se trouve-t-elle dans le cas continu ?** +> Vous voulez pousser sur un point qui est suffisamment éloigné de $Y^i$, car s'il est trop proche, les paramètres peuvent ne pas bouger beaucoup puisque la fonction définie par un réseau neuronal est « raide ». Mais en général, c'est difficile et c'est le problème que les méthodes de sélection d'échantillons contrastifs tentent de résoudre. Il n'y a pas une seule façon correcte de le faire. Une forme un peu plus générale pour les pertes contrastives de type charnière est : diff --git a/docs/fr/week11/11-3.md b/docs/fr/week11/11-3.md index 18e50a076..92cd2b645 100644 --- a/docs/fr/week11/11-3.md +++ b/docs/fr/week11/11-3.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.11-3 -title: “Prediction and Policy learning Under Uncertainty” (PPUU) +title: Prediction et apprentissage d'une politique sous incertitude lecturer: Alfredo Canziani authors: Anuj Menta, Dipika Rajesh, Vikas Patidar, Mohith Damarapati date: 14 Apr 2020 @@ -44,16 +44,16 @@ Yes, we can! Let us find out in the "Learning world model" section. Disons que nous voulons apprendre à conduire dans un modèle d'apprentissage par renforcement (RL). Nous entraînons des modèles en RL en laissant le modèle faire des erreurs et en apprenant de celles-ci. Mais ce n'est pas la meilleure façon de procéder car les erreurs peuvent nous conduire au paradis ou en enfer où il est inutile d'apprendre. -Parlons donc d'une méthode plus "humaine" pour apprendre à conduire une voiture. Prenons un exemple de changement de voie. En supposant que la voiture roule à 100 km/h, ce qui correspond à peu près à 30 m/s, si nous regardons à 30 m devant nous, nous regardons en gros 1 s dans le futur. +Parlons donc d'une méthode plus « humaine » pour apprendre à conduire une voiture. Prenons un exemple de changement de voie. En supposant que la voiture roule à 100 km/h, ce qui correspond à peu près à 30 m/s, si nous regardons à 30 m devant nous, nous regardons en gros 1 s dans le futur.

-Figure 1: Regarder vers l'avenir en conduisant +Figure 1 : Regarder vers l'avenir en conduisant
Si nous devions nous tourner, nous devons prendre une décision en fonction de l'avenir proche. Pour prendre un virage dans quelques mètres, nous prenons une mesure maintenant, qui dans ce contexte est de tourner le volant. Prendre une décision ne dépend pas seulement de votre conduite, mais aussi des véhicules environnants dans la circulation. Comme tout le monde autour de nous n'est pas aussi déterministe, il est très difficile de prendre en compte toutes les possibilités. -Décomposons maintenant ce qui se passe dans ce scénario. Nous avons un agent (représenté ici par un cerveau) qui prend l'entrée $s_t$ (images de position, de vitesse et de contexte) et produit une action $a_t$ (contrôle de la direction, accélération et freinage). L'environnement nous amène à un nouvel état et nous renvoie un coût $c_t$. +Décomposons maintenant ce qui se passe dans ce scénario. Nous avons un agent (représenté ici par un cerveau) qui prend l'entrée $s_t$ (images de position, de vitesse et de contexte) et produit une action $a_t$ (contrôle de la direction, accélération et freinage). L'environnement nous amène à un nouvel état et nous renvoie un coût $c_t$.

@@ -62,11 +62,10 @@ Décomposons maintenant ce qui se passe dans ce scénario. Nous avons un agent ( C'est comme un simple réseau où vous prenez des mesures dans un état donné et où le monde nous donne l'état suivant et la conséquence suivante. Il n'y a pas de modèle, car chaque action nous fait interagir avec le monde réel. Mais pouvons-nous entraîner un agent sans interagir avec le monde réel ? -Oui, c'est possible ! Découvrons-le dans la section "Apprentissage d’un modèle du monde".

-Figure 3: Illustration d'un agent dans le modèle du monde +Figure 3 : Illustration d'un agent dans le modèle du monde
@@ -88,14 +87,13 @@ The illustration in blue is the feed and the illustration in green is what we ca ## Jeu de données -Avant de discuter de la manière d'apprendre le modèle du monde, explorons l'ensemble des données dont nous disposons. Nous avons 7 caméras montées sur le toit d'un bâtiment de 30 étages qui fait face à l'autoroute. Nous ajustons les caméras pour obtenir une vue de haut en bas et extrayons ensuite des boîtes de délimitation pour chaque véhicule. A la fois $t$, nous pouvons déterminer $p_t$ représentant la position, $v_t$ -représentant la vitesse et $i_t$ représentant l'état actuel de la circulation autour du véhicule. +Avant de discuter de la manière d'apprendre le modèle du monde, explorons le jeu de données dont nous disposons. Nous avons 7 caméras montées sur le toit d'un bâtiment de 30 étages qui fait face à l'autoroute. Nous ajustons les caméras pour obtenir une vue de haut en bas et extrayons ensuite des boîtes de délimitation pour chaque véhicule. A la fois $t$, nous pouvons déterminer $p_t$ représentant la position, $v_t$ représentant la vitesse et $i_t$ représentant l'état actuel de la circulation autour du véhicule. -Comme nous connaissons la cinématique de la conduite, nous pouvons les inverser pour déterminer quelles sont les actions que le conducteur effectue. Par exemple, si la voiture se déplace dans un mouvement rectiligne uniforme, nous savons que l'accélération est nulle (ce qui signifie qu'il n'y a pas d'action) +Comme nous connaissons la cinématique de la conduite, nous pouvons les inverser pour déterminer quelles sont les actions que le conducteur effectue. Par exemple, si la voiture se déplace dans un mouvement rectiligne uniforme, nous savons que l'accélération est nulle (ce qui signifie qu'il n'y a pas d'action).

-Figure 4: Représentation mécanique d'une seule image +Figure 4 : Représentation mécanique d'une seule image
L'illustration en bleu est le flux et l'illustration en vert est ce que l'on peut appeler la représentation de la machine. Pour mieux comprendre cela, nous avons isolé quelques véhicules (marqués dans l'illustration). Les vues que nous voyons ci-dessous sont les cases limitant le champ de vision de ces véhicules. @@ -128,14 +126,14 @@ Il y a deux types de coûts différents ici : le coût de la voie et le coût de

-Figure 5: Coût des voies +Figure 5 : Coût des voies
-Dans la figure ci-dessus, les lignes pointillées représentent les voies réelles et les lignes rouges nous aident à calculer le coût de la voie compte tenu de la position actuelle de notre voiture. Les lignes rouges se déplacent en fonction de la position de notre voiture. La hauteur de l'intersection des lignes rouges avec la courbe potentielle (en cyan) nous donne le coût. Si la voiture est au centre de la voie, les deux lignes rouges se chevauchent avec les voies réelles, ce qui donne un coût nul. D'autre part, lorsque la voiture s'éloigne du centre, les lignes rouges se déplacent également, ce qui entraîne un coût non nul. +Dans la figure ci-dessus, les lignes pointillées représentent les voies réelles et les lignes rouges nous aident à calculer le coût de la voie compte tenu de la position actuelle de notre voiture. Les lignes rouges se déplacent en fonction de la position de notre voiture. La hauteur de l'intersection des lignes rouges avec la courbe potentielle (en cyan) nous donne le coût. Si la voiture est au centre de la voie, les deux lignes rouges se chevauchent avec les voies réelles, ce qui donne un coût nul. D'autre part, lorsque la voiture s'éloigne du centre, les lignes rouges se déplacent également, ce qui entraîne un coût non nul.

-Figure 6: Coût de proximité +Figure 6 : Coût de proximité
Le coût de proximité a deux composantes ($\mathcal{L}_x$ et $\mathcal{L}_y$). $\mathcal{L}_y$ est similaire au coût de la voie et $\mathcal{L}_x$ dépend de la vitesse de notre voiture. La courbe orange de la figure 6 nous renseigne sur la distance de sécurité. Plus la vitesse de la voiture augmente, plus la courbe orange s'élargit. Plus la voiture roule vite, plus il faut regarder devant et derrière. La hauteur de l'intersection d'une voiture avec la courbe orange détermine $\mathcal{L}_x$. @@ -157,10 +155,10 @@ The world model is fed with an action $a_t$ (steering, brake, and acceleration)

-Figure 7: Illustration d’un modèle du monde +Figure 7 : Illustration d’un modèle du monde
-Le modèle du monde est alimenté par une action $a_t$ (direction, freinage et accélération) et $s_{1:t}$ (séquence d'états où chaque état est représenté par des images de position, de vitesse et de contexte à ce moment) et il prédit l'état suivant $\hat s_{t+1}$. D'autre part, nous avons le monde réel qui nous dit ce qui s'est réellement passé ($s_{t+1}$). Nous optimisons la MSE (Mean Squared Error) entre la prédiction ($\hat s_{t+1}$) et la cible ($s_{t+1}$) pour entraîner notre modèle. +Le modèle du monde est alimenté par une action $a_t$ (direction, freinage et accélération) et $s_{1:t}$ (séquence d'états où chaque état est représenté par des images de position, de vitesse et de contexte à ce moment) et il prédit l'état suivant $\hat s_{t+1}$. D'autre part, nous avons le monde réel qui nous dit ce qui s'est réellement passé ($s_{t+1}$). Nous optimisons la MSE (*Mean Squared Error*) entre la prédiction ($\hat s_{t+1}$) et la cible ($s_{t+1}$) pour entraîner notre modèle. + ## Imiter l'expert Comment imiter les experts ici ? Nous voulons que la prévision de notre modèle après une action particulière d'un état soit aussi proche que possible de l'avenir réel. Cela permet de régulariser les experts pour notre entraînement. Notre fonction de coût comprend maintenant à la fois le coût spécifique de la tâche (coût de proximité et coût de la voie) et ce terme d'expert régularisateur. Maintenant que nous calculons également la perte par rapport à l'avenir réel, nous devons supprimer la variable latente du modèle parce qu'elle nous donne une prédiction spécifique, mais ce paramètre fonctionne mieux si nous travaillons uniquement avec la prédiction moyenne. @@ -470,14 +469,14 @@ $$

-Figure 21: Architecture de modèle basée sur la régularisation experte +Figure 21 : Architecture de modèle basée sur la régularisation experte
-Alors, comment ce modèle fonctionne-t-il ? +Comment ce modèle fonctionne-t-il ?

-Figure 22: Politique apprise en imitant les experts +Figure 22 : Politique apprise en imitant les experts
Comme nous pouvons le voir dans la figure ci-dessus, le modèle fonctionne en fait incroyablement bien et apprend à faire de très bonnes prévisions. C'était un apprentissage par imitation basé sur le modèle, nous avons essayé de modeler notre agent pour essayer d'imiter les autres. @@ -530,12 +529,12 @@ Si nous entraînons plusieurs modèles sur les mêmes données, tous ces modèle

-Figure 23: Visualisation des coûts sur l'ensemble de l'espace d'entrée +Figure 23 : Visualisation des coûts sur l'ensemble de l'espace d'entrée
Pour en revenir à notre discussion, nous constatons que l'apprentissage d'une politique à l'aide de données d'observation uniquement est difficile car la distribution des états qu'elle produit au moment de l'exécution peut différer de ce qui a été observé pendant la phase d'entraînement. Le modèle du monde peut faire des prédictions arbitraires en dehors du domaine sur lequel il a été entraîné, ce qui peut entraîner des coûts peu élevés. Le réseau politique peut alors exploiter ces erreurs dans le modèle dynamique et produire des actions qui conduisent à des états faussement optimistes. -Pour y remédier, nous proposons un coût supplémentaire qui mesure l'incertitude du modèle dynamique sur ses propres prédictions. Ce coût peut être calculé en faisant passer la même entrée et la même action par plusieurs masques de dropout différents, et en calculant la variance entre les différentes sorties. Cela encourage le réseau politique à ne produire que des actions pour lesquelles le modèle de prospective est confiant. +Pour y remédier, nous proposons un coût supplémentaire qui mesure l'incertitude du modèle dynamique sur ses propres prédictions. Ce coût peut être calculé en faisant passer la même entrée et la même action par plusieurs masques de *dropout* différents, et en calculant la variance entre les différentes sorties. Cela encourage le réseau politique à ne produire que des actions pour lesquelles le modèle de prospective est confiant. $$ \mathcal{L} = c_\text{task} + \lambda c_\text{uncertainty} @@ -543,16 +542,15 @@ $$

-Figure 24: Architecture de modèle basée sur la régularisation de l'incertitude +Figure 24 : Architecture de modèle basée sur la régularisation de l'incertitude
Alors, la régularisation de l'incertitude nous aide-t-elle à apprendre une meilleure politique ? - -Oui, il le fait. La politique ainsi apprise est meilleure que les modèles précédents. +Oui. La politique ainsi apprise est meilleure que les modèles précédents.

-Figure 25: Politique apprise basée sur la régularisation de l'incertitude +Figure 25 : Politique apprise basée sur la régularisation de l'incertitude
-## Conférence partie A +## Cours magistral partie A -Dans cette section, nous discutons des fonctions d'activation communes à Pytorch. En particulier, nous comparons les activations avec coude(s) par rapport aux activations lisses. La première est préférée dans un réseau neuronal profond car la seconde pourrait souffrir d'un problème de disparition du gradient. Nous découvrons ensuite les fonctions de perte communes à Pytorch. +Dans cette section, nous discutons des fonctions d'activation communes dans PyTorch. En particulier, nous comparons les activations avec coude(s) par rapport aux activations lisses. La première est préférée dans un réseau neuronal profond car la seconde pourrait souffrir d'un problème de disparition du gradient. Nous découvrons ensuite les fonctions de perte communes dans PyTorch. -## Conférence partie B +## Cours magistral partie B -Dans cette section, nous continuons de nous informer sur les fonctions de perte - en particulier, les pertes basées sur la marge et leurs applications. Nous discutons ensuite de la manière de concevoir une bonne fonction de perte pour les EBMs ainsi que des exemples de fonctions de perte bien connues des EBMs. Nous accordons une attention particulière à la fonction de perte basée sur la marge, tout en expliquant l'idée de "réponse incorrecte la plus offensante". +Dans cette section, nous continuons de nous informer sur les fonctions de perte en particulier les pertes basées sur une marge et leurs applications. Nous discutons ensuite de la manière de concevoir une bonne fonction de perte pour les EBMs ainsi que des exemples de fonctions de perte bien connues des EBMs. Nous accordons une attention particulière à la fonction de perte basée sur une marge, tout en expliquant l'idée de réponse incorrecte la plus offensante. -## Pratique -Nous proposons un apprentissage efficace pour la conduite dans un trafic dense. Nous entraînons de multiples politiques en déroulant un modèle appris de la dynamique du monde réel en optimisant différentes fonctions de coût. L'idée est de minimiser l'incertitude dans les prévisions du modèle en introduisant un terme de coût qui représente la divergence du modèle par rapport aux états sur lesquels il est entraîné. - - - +## Travaux dirigés +Nous proposons un apprentissage efficace pour la conduite dans un trafic dense. Nous entraînons de multiples politiques en déroulant un modèle appris de la dynamique du monde réel en optimisant différentes fonctions de coût. L'idée est de minimiser l'incertitude dans les prédictions du modèle en introduisant un terme de coût qui représente la divergence du modèle par rapport aux états sur lesquels il est entraîné. diff --git a/docs/fr/week12/12-1.md b/docs/fr/week12/12-1.md index a9a63da2f..ac8f7975b 100644 --- a/docs/fr/week12/12-1.md +++ b/docs/fr/week12/12-1.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.12-1 -title: Apprentissage profond pour le NLP +title: Apprentissage profond pour le traitement du langage naturel lecturer: Mike Lewis authors: Jiayu Qiu, Yuhong Zhu, Lyuang Fu, Ian Leefmans date: 20 Apr 2020 @@ -20,12 +20,12 @@ translator: Loïck Bourdois * Minimal specialist techniques needed per task, can achieve these things with fairly generic models --> -## [Aperçu](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=44s) +## [Vue d'ensemble](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=44s) * Progrès impressionnants au cours des dernières années : - Les humains préfèrent la traduction automatique aux traducteurs humains pour certaines langues - Des performances supérieures à l’humaine pour de nombreux ensembles de données de réponse aux questions - - Les modèles linguistiques génèrent des paragraphes fluides (par exemple Radford et al. 2019) + - Les modèles linguistiques génèrent des paragraphes fluides (par exemple [Radford et al. (2019)](https://openai.com/blog/better-language-models/)) * Un minimum de techniques spécialisées nécessaires par tâche, peut être réalisé avec des modèles assez génériques @@ -40,10 +40,9 @@ translator: Loïck Bourdois $$p(x_0,...x_n) = p(x_0)p(x_1 \mid x_0) \cdots p(x_n \mid x_{n-1})$$ --> -## Modèles linguistiques +## Modèles de langue -* Les modèles linguistiques attribuent une probabilité à un texte : - $p(x_0, \cdots, x_n)$ +* Les modèles linguistiques attribuent une probabilité à un texte : $p(x_0, \cdots, x_n)$ * Beaucoup de phrases possibles donc on ne peut pas juste entraîner un classifieur * La méthode la plus populaire consiste à factoriser la distribution en utilisant la règle de la chaîne : @@ -62,15 +61,15 @@ $$p(x_0 \mid x_{0, \cdots, n-1}) = \text{softmax}(E f(x_{0, \cdots, n-1}))$$ --> -## Modèles linguistiques neuronaux +## Modèles de langue neuronaux -Grossièrement, nous introduisons le texte dans un réseau de neurones, le réseau de neurones va cartographier tout ce contexte sur un vecteur. Ce vecteur représente le mot suivant et nous disposons d'une matrice d'enchâssement de mots importants. Cette matrice contient un vecteur pour chaque mot possible que le modèle peut produire. Nous calculons ensuite la similarité par le produit scalaire du vecteur de contexte et de chacun des vecteurs de mots. Nous obtiendrons une probabilité de prédire le mot suivant, puis nous entraînerons ce modèle par maximum de vraisemblance. Le détail clé ici est que nous ne traitons pas directement les mots, mais nous traitons des choses appelées sous-mots ou caractères. +Grossièrement, nous entrons le texte dans un réseau de neurones, le réseau de neurones va associer tout ce contexte à un vecteur. Ce vecteur représente le mot suivant et nous disposons d'une matrice d'enchâssement de mots importants. Cette matrice contient un vecteur pour chaque mot possible que le modèle peut produire. Nous calculons ensuite la similarité par le produit scalaire du vecteur de contexte et de chacun des vecteurs de mots. Nous obtienenons une probabilité de prédire le mot suivant, puis nous entraînons ce modèle par maximum de vraisemblance. Le détail clé ici est que nous ne traitons pas directement les mots mais des choses des sous-mots ou des caractères. $$p(x_0 \mid x_{0, \cdots, n-1}) = \text{softmax}(E f(x_{0, \cdots, n-1}))$$
-
Fig.1 : Modèle linguistique neuronal
+
Figure 1 : Modèle de langue neuronal
-### Modèles linguistiques convolutifs +### Modèles de langue convolutifs -* Le premier modèle linguistique neural -* Intégrer chaque mot comme un vecteur, qui est une table de recherche de la matrice d'enchâssement, de sorte que le mot obtienne le même vecteur quel que soit le contexte dans lequel il apparaît -* Appliquer le même réseau feed forward à chaque étape -* Malheureusement, l'historique à durée fixe signifie qu'il ne peut être conditionné qu'à un contexte délimité -* Ces modèles ont l'avantage d'être très rapides +* Il s'agit du premier type de modèle linguistique neural. +* Il consiste à enchâsser chaque mot comme un vecteur, qui est une table de recherche de la matrice d'enchâssement, de sorte que le mot obtienne le même vecteur quel que soit le contexte dans lequel il apparaît. On aoplique ensuite le même réseau *feed forward* à chaque pas de temps. +* Malheureusement, la longueur fixe signifie qu'il ne peut être conditionné qu'à un contexte délimité +* Ces types de modèles ont l'avantage d'être très rapides.
-
Fig.2 : Modèle linguistique convolutif
+
Figure 2 : Modèle de langue convolutif
@@ -120,7 +118,7 @@ $$p(x_0 \mid x_{0, \cdots, n-1}) = \text{softmax}(E f(x_{0, \cdots, n-1}))$$ --> -### Modèles linguistiques récurrents +### Modèles de langue récurrents * L'approche la plus populaire jusqu'à il y a quelques années. * Conceptuellement simple : à chaque pas de temps, nous maintenons un certain état (reçu du pas de temps précédent, qui représente ce que nous avons lu jusqu'à présent). Ceci est combiné avec le mot courant qui est lu et utilisé à l'état ultérieur. Ensuite, nous répétons ce processus pour autant de pas de temps que nécessaire. @@ -128,11 +126,11 @@ $$p(x_0 \mid x_{0, \cdots, n-1}) = \text{softmax}(E f(x_{0, \cdots, n-1}))$$ * Inconvénients : - Toute l'histoire de la lecture du document est compressée en un vecteur de taille fixe à chaque étape temporelle, ce qui constitue le goulot d'étranglement de ce modèle - Les gradients ont tendance à disparaître avec des contextes longs - - Impossible à mettre en parallèle avec les étapes du temps, donc entraînement lent + - Impossible àde paralléliser les étapes temporelles donc l'entraînement est lent
-
Fig.3 : Modèle linguistique récurrent
+
Figure 3 : Modèle de langue récurrent
-### [Modèles linguistique basé sur un transformer](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=828s) +### [Modèles d elangue basé sur un transformer](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=828s) -* Modèle le plus récent utilisé en NLP -* Pénalité révolutionnaire -* Trois grandes étapes +* Modèle le plus récent utilisé en traitement du langage naturel. +* Pénalité révolutionnaire. +* Trois grandes étapes : * Étape d'entrée * $n$ fois les blocs de transformer (couches d'encodage) avec différents paramètres * Etape de sortie -* Exemple avec 6 modules de transformer (couches d'encodage) dans le papier original introduisant le transformer: + * +* Exemple avec 6 modules de transformer (couches d'encodage) dans le papier introduisant le transformer :
-
Fig.4:Modèle linguistique de type transformer
+
Figure 4 : Modèle de langue de type transformer
-Les sous-couches sont reliées par les cases intitulées "Add&Norm". La partie "Add" signifie qu'il s'agit d'une connexion résiduelle, qui contribue à empêcher la disparition du gradient. La norme désigne ici la normalisation des couches. +Les sous-couches sont reliées par les cases intitulées *Add&Norm*. La partie *Add* signifie qu'il s'agit d'une connexion résiduelle, qui contribue à empêcher la disparition du gradient. La partie *Norm* désigne ici la normalisation des couches.
-
Fig.5 : Couche de codage
+
Figure 5 : Couche encodeur
Il convient de noter que les transformers partagent les poids entre les étapes du temps. @@ -224,11 +223,11 @@ One detail to make the transformer language model work is to add the positional --> -# Attention à plusieurs têtes +# Attention multi-têtes
-
Fig.6 : Attention multi-têtes
+
Figure 6 : Attention multi-têtes
@@ -242,29 +241,29 @@ Une fois que nous avons les valeurs (v), nous calculons les états cachés en ma $$h_i = \sum_{i}{p_i v_i}$$ -Nous calculons la même chose avec différentes requêtes, valeurs et clés plusieurs fois en parallèle. La raison en est que nous voulons prédire le mot suivant en utilisant différentes choses. Par exemple, lorsque nous prédisons le mot "licornes" en utilisant les trois mots précédents "Celles-ci", "cornues" et "blanc argenté". Nous savons que c'est une licorne par "cornu" "blanc argenté". Cependant, nous pouvons savoir qu'il s'agit du pluriel "licornes" par "Celles-ci". Par conséquent, nous voulons probablement utiliser ces trois mots pour savoir quel sera le prochain mot. L'attention à plusieurs têtes est une façon de laisser chaque mot regarder plusieurs mots précédents. +Nous calculons la même chose avec différentes requêtes, valeurs et clés plusieurs fois en parallèle. La raison en est que nous voulons prédire le mot suivant en utilisant différentes choses. Par exemple, lorsque nous prédisons le mot « licornes » en utilisant les trois mots précédents « Celles-ci », « cornues » et « blanc argenté ». Nous savons que c'est une licorne par « cornue » et « blanc argenté » . Cependant, nous pouvons savoir qu'il s'agit du pluriel « licornes » par « Celles-ci » . Par conséquent, nous voulons probablement utiliser ces trois mots pour savoir quel sera le prochain mot. L'attention à plusieurs têtes est une façon de laisser chaque mot regarder plusieurs mots précédents. -Un grand avantage de l'attention multi-têtes est qu'elle est très parallélisable. Contrairement aux RNN, le calcul de toutes les têtes des modules d'attention multi-têtes et toutes les étapes de temps peut se faire en même temps. Un des problèmes du calcul de tous les pas de temps en une fois est qu'il pourrait également examiner les mots futurs, alors que nous ne voulons que conditionner les mots précédents. Une solution à ce problème est ce que l'on appelle le **masquage de l'auto-attention**. Le masque est une matrice triangulaire supérieure qui comporte des zéros dans le triangle inférieur et une infinité négative dans le triangle supérieur. L'effet de l'ajout de ce masque à la sortie du module d'attention est que chaque mot à gauche a un score d'attention beaucoup plus élevé que les mots à droite, de sorte que le modèle en pratique se concenter uniquement sur les mots précédents. L'application du masque est cruciale dans le modèle linguistique car elle le rend mathématiquement correct, cependant, dans les encodeurs de texte, le contexte bidirectionnel peut être utile. +Un grand avantage de l'attention multi-têtes est qu'elle est très parallélisable. Contrairement aux RNNs, le calcul de toutes les têtes des modules d'attention multi-têtes et toutes les étapes de temps peut se faire en même temps. Un des problèmes du calcul de tous les pas de temps en une fois est qu'il pourrait également examiner les mots futurs, alors que nous ne voulons que conditionner les mots précédents. Une solution à ce problème est ce que l'on appelle le **masquage de l'auto-attention**. Le masque est une matrice triangulaire supérieure qui comporte des zéros dans le triangle inférieur et une infinité négative dans le triangle supérieur. L'effet de l'ajout de ce masque à la sortie du module d'attention est que chaque mot à gauche a un score d'attention beaucoup plus élevé que les mots à droite, de sorte que le modèle en pratique se concenter uniquement sur les mots précédents. L'application du masque est cruciale dans le modèle linguistique car elle le rend mathématiquement correct, cependant, dans les encodeurs de texte, le contexte bidirectionnel peut être utile. Un détail pour faire fonctionner le transformer est d'ajouter l'enchâssement positionnel à l'entrée (l’ordre des mots dans un texte). Dans le langage, certaines propriétés comme l'ordre sont importantes à interpréter. La technique utilisée ici est l'apprentissage d’enchâssements séparés à différents moments et l'ajout de celles-ci à l'entrée, de sorte que l'entrée est maintenant la somme du vecteur mot et du vecteur positionnel. Cela donne des informations sur l'ordre.
-
Fig.7 : Architecture du transformer
+
Figure 7 : Architecture du transformer
-**Pourquoi le modèle est si bon:** +**Pourquoi le modèle est si bon :** -1. Il donne des liens directs entre chaque paire de mots. Chaque mot peut accéder directement aux états cachés des mots précédents, ce qui atténue la disparition des gradients. Il apprend très facilement une fonction très coûteuse -2. Toutes les étapes du temps sont calculées en parallèle -3. L'auto-attention est quadratique (tous les pas de temps peuvent s'occuper de tous les autres), ce qui limite la longueur maximale des sequences +1. Il donne des liens directs entre chaque paire de mots. Chaque mot peut accéder directement aux états cachés des mots précédents, ce qui atténue la disparition des gradients. Il apprend très facilement une fonction très coûteuse. +2. Toutes les étapes du temps sont calculées en parallèle. +3. L'auto-attention est quadratique (tous les pas de temps peuvent s'occuper de tous les autres), ce qui limite la longueur maximale des sequences. -## [Quelques astuces (notamment pour l'attention multi-tête et le codage positionnel) et le décodage des modèles linguistiques](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=1975s) +## [Quelques astuces (notamment pour l'attention multi-tête et le codage positionnel) et le décodage des modèles de langue](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=1975s) -### Astuce 1 : L'utilisation extensive de la normalisation des couches pour stabiliser l'entraînement +### Astuce 1 : l'utilisation de la normalisation des couches pour stabiliser l'entraînement - Astuce très importante pour les transformers @@ -281,9 +280,9 @@ Un détail pour faire fonctionner le transformer est d'ajouter l'enchâssement p - Make use of learning rate schedule: in order to make the transformers work well, you have to make your learning rate decay linearly from zero to thousandth steps. --> -### Astuce 2 : Échauffement (Warm-up) + grille d'entraînement de la racine carrée inversée +### Astuce 2 : échauffement (*warm-up*) et grille d'entraînement utilisant la racine carrée inverse -- Utilisez une grille de taux d'apprentissage : pour que les transformers fonctionnent bien, vous devez faire décroître votre taux d'apprentissage de façon linéaire de zéro à des millièmes de pas. +- Utilisez une grille de taux d'apprentissage fonctionnent bien pour que les transformers. Vous devez faire décroître votre taux d'apprentissage de façon linéaire de zéro à des millièmes de pas. -### Truc 3 : Soigner l’initialisation +### Truc 3 : soigner l’initialisation - Vraiment utile pour une tâche comme la traduction automatique @@ -310,15 +309,15 @@ The following are the results from some methods mentioned above. In these tests, You could see that when transformers were introduced, the performance was greatly improved. --> -### Astuce 4 : Lissage +### Astuce 4 : lissage - Vraiment utile pour une tâche comme la traduction automatique -Voici les résultats de certaines méthodes mentionnées ci-dessus. Dans ces tests, la métrique de droite appelée `ppl` était la perplexité (plus le `ppl` est bas, mieux c'est). +Voici les résultats de certaines méthodes mentionnées ci-dessus. Dans ces tests, la métrique de droite appelée `ppl` était la perplexité (plus la `ppl` est basse, mieux c'est).
-
Fig.8 : Comparaison des performances des modèles
+
Figure 8 : Comparaison des performances des modèles
Vous avez pu constater que lorsque les transformers ont été introduits, la performance a été grandement améliorée. @@ -345,16 +344,14 @@ Self attention is quadratic (all time-steps can attend to all others), limiting - Biais inductif minime - Tous les mots sont directement liés, ce qui atténue la disparition des gradients - - Tous les pas de temps calculés en parallèle - + - Tous les pas de temps sont calculés en parallèle -L'auto-attention est quadratique (tous les pas de temps peuvent s'occuper de tous les autres), ce qui limite la longueur maximale de la séquence. -- Comme l'auto-attention est quadratique, sa dépense augmente linéairement dans la pratique, ce qui pourrait poser un problème. +L'auto-attention est quadratique (tous les pas de temps peuvent s'occuper de tous les autres), ce qui limite la longueur maximale de la séquence. La nature quadratique entraîne aussi que la dépense augmente linéairement ce qui pourrait poser un problème en pratique.
-
Fig.9 : Transformateurs *vs.* RNNs
+
Figure 9 : Transformateurs vs RNNs
-### Les transformers s'adaptent très bien +### Les transformers passent à l'échelle très bien -1. Des données illimitées sur l'entraînement, bien plus que ce dont vous avez besoin -2. Le GPT 2 a utilisé 2 milliards de paramètres en 2019 -3. Les modèles récents utilisent plusieurs milliards de paramètres : 17Mds pour le T5, 175Mds pour le GPT3. +1. Des données illimitées pour l'entraînement (n'importe quel texte sur internet), bien plus que ce dont vous avez besoin. +2. Le GPT-2 a utilisé 2 milliards de paramètres en 2019. +3. Les modèles récents (lors de ce cours en 2020) utilisent plusieurs milliards de paramètres : 17Mds pour le T5, 175Mds pour le GPT3. -## Décodage des modèles linguistiques +## Décodage des modèles de langue + +Cette section est détaillée netemment plus en détaille dans la partie 2 de la semaine 12 disponible [ici](https://atcold.github.io/pytorch-Deep-Learning/fr/week12/12-2/). + -Nous pouvons maintenant entraîner une distribution de probabilité sur le texte. Grossièrement, nous pourrions obtenir un nombre exponentiel de sorties possibles, donc nous ne pouvons pas calculer le maximum. Le choix que vous ferez pour votre premier mot pourrait avoir une incidence sur toutes les autres décisions. -Ainsi, étant donné cela, le décodage gourmand (greedy decoding) a été introduit comme suit. +Nous pouvons maintenant entraîner une distribution de probabilité sur le texte. Grossièrement, nous pouvons obtenir un nombre exponentiel de sorties possibles donc nous ne pouvons pas calculer le maximum. Le choix effectué pour votre premier mot peut avoir une incidence sur toutes les autres décisions. +Ainsi, étant donné cela, le décodage gourmand (*greedy decoding*) a été introduit comme suit. -## Questions / réponses -1. Quel est l'avantage d'un modèle d'attention à plusieurs têtes par rapport à un modèle d'attention à une seule tête ? - * Pour prédire le mot suivant, vous devez observer plusieurs choses séparées, en d'autres termes, l'attention peut être portée sur plusieurs mots précédents en essayant de comprendre le contexte nécessaire pour prédire le mot suivant. +## Questions des étuidants +**Quel est l'avantage d'un modèle d'attention à plusieurs têtes par rapport à un modèle d'attention à une seule tête ?** +> Pour prédire le mot suivant, vous devez observer plusieurs choses séparées, en d'autres termes, l'attention peut être portée sur plusieurs mots précédents en essayant de comprendre le contexte nécessaire pour prédire le mot suivant. -2. Comment les transformers résolvent-ils les goulots d'étranglement informationnels des ConvNets et des RNN ? - * Les modèles d'attention permettent une connexion directe entre tous les mots, ce qui permet de conditionner chaque mot à tous les mots précédents, éliminant ainsi efficacement ce goulot d'étranglement. +**Comment les transformers résolvent-ils les goulots d'étranglement informationnels des ConvNets et des RNNs ?** +> Les modèles d'attention permettent une connexion directe entre tous les mots, ce qui permet de conditionner chaque mot à tous les mots précédents, éliminant ainsi efficacement ce goulot d'étranglement. -3. En quoi les transformers diffèrent-ils des RNN dans la manière dont ils exploitent la parallélisation des GPU ? - * Les modules d'attention multi-têtes des transformers sont hautement parallélisables alors que les RNN ne le sont pas et ne peuvent donc pas tirer profit de la technologie GPU. En fait, les transformers calculent tous les pas de temps en une seule passe vers l'avant. +**En quoi les transformers diffèrent-ils des RNNs dans la manière dont ils exploitent la parallélisation des GPUs ?** +> Les modules d'attention multi-têtes des transformers sont hautement parallélisables alors que les RNNs ne le sont pas et ne peuvent donc pas tirer profit de la technologie GPU. En fait, les transformers calculent tous les pas de temps en une seule passe vers l'avant. diff --git a/docs/fr/week12/12-2.md b/docs/fr/week12/12-2.md index 59c78462c..ab6ecfbbe 100644 --- a/docs/fr/week12/12-2.md +++ b/docs/fr/week12/12-2.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.12-2 -title: Décoder les modèles linguistiques +title: Décoder les modèles de langue lecturer: Mike Lewis authors: Trevor Mitchell, Andrii Dobroshynskyi, Shreyas Chandrakaladharan, Ben Wolfson date: 20 Apr 2020 @@ -33,24 +33,25 @@ At training time, the algorithm often does not use a beam, because it is very ex Summary: Continue beam search until all $k$ hypotheses produce end token or until the maximum decoding limit T is reached. --> -## [Recherche par faisceau](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=2732s) +## [Recherche en faisceau](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=2732s) -La recherche par faisceau est une autre technique pour décoder un modèle de langue et produire du texte. À chaque étape, l'algorithme garde une trace des $k$ plus probables (meilleures) traductions partielles (hypothèses). Le score de chaque hypothèse est égal à son logarithme de probabilité. +La recherche en faisceau est une autre technique pour décoder un modèle de langue et produire du texte. À chaque étape, l'algorithme garde une trace des $k$ plus probables (meilleures) traductions partielles (hypothèses). Le score de chaque hypothèse est égal à son logarithme de probabilité. -L'algorithme sélectionne la meilleure hypothèse de notation. +L'algorithme sélectionne la meilleure hypothèse basée sur un score.

-Fig. 1 : Décodage par faisceau +Figure 1 : : Décodage en faisceau
-A quelle profondeur l'arbre des faisceaux se ramifie-t-il ? + +**A quelle profondeur l'arbre des faisceaux se ramifie-t-il ?** L'arbre des faisceaux continue jusqu'à ce qu'il atteigne le token de fin de phrase. Une fois le token de fin de phrase émis, l'hypothèse est terminée. -Pourquoi les très grandes tailles de faisceau entraînent-elles souvent des traductions vides ? +**Pourquoi les très grandes tailles de faisceau entraînent-elles souvent des traductions vides ?** -Au moment de l'entraînement, l'algorithme n'utilise souvent pas de faisceau, car c’est très coûteux. Il utilise plutôt la factorisation auto-régressive (en fonction des sorties correctes précédentes, prédire les premiers mots $n+1$). Le modèle n'est pas exposé à ses propres erreurs pendant l'entraînement, il est donc possible que des "absurdités" apparaissent dans le faisceau. +Au moment de l'entraînement, l'algorithme n'utilise souvent pas de faisceau, car c’est très coûteux. Il utilise plutôt la factorisation auto-régressive (en fonction des sorties correctes précédentes, prédire les premiers mots $n+1$). Le modèle n'est pas exposé à ses propres erreurs pendant l'entraînement, il est donc possible que des absurdités apparaissent dans le faisceau. Résumé : continuer la recherche de faisceau jusqu'à ce que toutes les hypothèses $k$ produisent un token de fin ou jusqu'à ce que la limite maximale de décodage T soit atteinte. @@ -67,7 +68,7 @@ However, sampling from the model distribution poses its own problem. Once a "bad Nous ne voulons peut-être pas la séquence la plus probable. Nous pouvons plutôt prélever un échantillon à partir de la distribution du modèle. -Cependant, l'échantillonnage à partir de la distribution du modèle pose son propre problème. Une fois qu'un "mauvais" choix est échantillonné, le modèle se trouve dans un état auquel il n'a jamais été confronté pendant l’entraînement, ce qui augmente la probabilité qu'une "mauvaise" évaluation continue. L'algorithme peut donc se retrouver coincé dans d'horribles boucles de rétroaction. +Cependant, l'échantillonnage à partir de la distribution du modèle pose son propre problème. Une fois qu'un mauvais choix est échantillonné, le modèle se trouve dans un état auquel il n'a jamais été confronté pendant l’entraînement, ce qui augmente la probabilité qu'une mauvaise évaluation continue. L'algorithme peut donc se retrouver coincé dans d'horribles boucles de rétroaction. - + -#### Question : Pourquoi l'échantillonnage Top-K fonctionne-t-il si bien ? +#### Question : Pourquoi l'échantillonnage top-k fonctionne-t-il si bien ? Cette technique fonctionne bien parce qu'en utilisant seulement la tête de la distribution et en coupant la queue, elle essaie essentiellement d'éviter de tomber dans la multitude des bonnes langues lorsque nous échantillonnons quelque chose de mauvais. @@ -133,12 +134,11 @@ Examples: - Given a question, generate the answer --> -### Modèles linguistiques conditionnels +### Modèles de langue conditionnels Les modèles linguistiques conditionnels ne sont pas utiles pour générer des échantillons d'anglais aléatoires, mais ils sont utiles pour générer un texte à partir d'une entrée. Exemples : - - A partir d'une phrase française, générer la traduction anglaise - A partir d'un document, générer un résumé - Après un dialogue, générer la réponse suivante @@ -159,11 +159,11 @@ Generally, the input text is encoded. This resulting embedding is known as a "th ### Modèles de séquence à séquence -En général, le texte d'entrée est encodé. L’enchâssement résultant est connu sous le nom de "vecteur de pensée", qui est ensuite transmis au décodeur pour générer des tokens mot par mot. +En général, le texte d'entrée est encodé. L’enchâssement résultant est connu sous le nom de « vecteur de pensée », qui est ensuite transmis au décodeur pour générer des tokens mot par mot.

-Fig. 3 : Vecteur de pensée +Figure 3 : Vecteur de pensée
-## Apprentissage non supervisé en NLP +## Apprentissage non supervisé en traitement du langage naturel Il y a d'énormes quantités de texte sans aucun label et peu de données contrôlées. Que pouvons-nous apprendre sur la langue en lisant simplement un texte non étiqueté ? @@ -345,29 +342,30 @@ Word embeddings hold some structure - Shows some meaningful differences between vectors --> -### `word2vec` +### *Word2vec* L'intuition est que si des mots apparaissent proches les uns des autres dans le texte, ils sont probablement liés. Nous espérons donc qu'en regardant simplement un texte anglais non labellisé, nous pouvons apprendre ce qu'ils signifient. -- L'objectif est d'apprendre les représentations spatiales vectorielles des mots (apprendre les enchâssements) +- L'objectif est d'apprendre les représentations spatiales vectorielles des mots (apprendre les enchâssements). Tâche de pré-entraînement : masquer un mot et utiliser les mots voisins pour remplir les blancs.

-Fig. 7 : word2vec masquant le visuel +Figure 7 : Word2vec masquant le visuel
-Par exemple, ici, l'idée est que les "cornes" et les "cheveux argentés" sont plus susceptibles d'apparaître dans le contexte de la "licorne" que d'autres animaux. +Par exemple, ici, l'idée est que les « cornes » et les « cheveux argentés » sont plus susceptibles d'apparaître dans le contexte de la « licorne » que d'autres animaux. + -Prenez les mots et appliquez une projection linéaire +En appliquant une projection linéaire sur les mots :

-Fig. 8 : Enchâssement de word2vec +Figure 8 : Enchâssements de Word2vec
-Vous voulez savoir +On veut savoir $$ p(\texttt{licorne} \mid \texttt{Ces cheveux argentés étaient auparavant inconnus}) @@ -381,34 +379,32 @@ Les enchâssements de mots contiennent une certaine structure

-Fig. 9 : Exemple de structure d’enchâssements +Figure 9 : Exemple de structure d’enchâssements
-- L'idée est que si nous prenons la représentation vectorielle de "roi" après l'entraînement et que nous ajoutons celle pour "femelle", nous obtiendrons une représentation très proche de celle de "reine" -- Montre quelques différences significatives entre les vecteurs +- L'idée est que si nous prenons la représentation vectorielle de « roi » après l'entraînement et que nous ajoutons celle pour « femelle », nous obtiendrons une représentation très proche de celle de « reine ». + - -#### Question : Le mot "représentation" dépend-il ou non du contexte ? -Indépendant et n'a aucune idée des relations avec d'autres mots - - - - -#### Question : Quel serait un exemple de situation dans laquelle ce modèle se débattrait ? +#### Questions d'étudiants + +**Le mot « représentation » dépend-il ou non du contexte ?** +> Indépendant et n'a aucune idée des relations avec d'autres mots + + +**Quel serait un exemple de situation dans laquelle ce modèle aurait du mal ?** +> Les enchâssements de mots dépendent fortement du contexte. Ainsi, dans le cas de mots ambigus, des mots qui peuvent avoir des significations multiples, le modèle aura du mal car les vecteurs ne captureront pas le contexte nécessaire pour comprendre correctement le mot. -Les enchâssements de mots dépendent fortement du contexte. Ainsi, dans le cas de mots ambigus - des mots qui peuvent avoir des significations multiples - le modèle aura du mal car les vecteurs ne captureront pas le contexte nécessaire pour comprendre correctement le mot. -## [Pré-entraînement en NLP](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=4963s) +## [Pré-entraînement en traitement du langage naturel](https://www.youtube.com/watch?v=6D4EWKJgNn0&t=4963s) -Examinons rapidement les différentes approches de pré-entraînement auto-supervisé qui ont été étudiées en NLP. +Examinons rapidement les différentes approches de pré-entraînement autosupervisé qui ont été étudiées en en traitement du langage naturel : - XLNet : - Au lieu de prédire tous les tokens masqués de façon conditionnelle et indépendante, XLNet prédit les tokens masqués de façon auto-régressive et dans un ordre aléatoire - SpanBERT - - Les masques s'étendent (séquence de mots consécutifs) au lieu des tokens + Les masques s'étendent (séquence de mots consécutifs) au lieu des jetons - ELECTRA : + Plutôt que de masquer les mots, nous remplaçons les jetons par des mots similaires. Ensuite, nous résolvons un problème de classification binaire en essayant de prédire si les jetons ont été substitués ou non. - Plutôt que de masquer les mots, nous remplaçons les tokens par des mots similaires. Ensuite, nous résolvons un problème de classification binaire en essayant de prédire si les tokens ont été substitués ou non. - -- ALBERT : - - A Lite Bert : Nous modifions BERT et le rendons plus léger en liant les poids entre les couches. Cela réduit les paramètres du modèle et les calculs impliqués. Il est intéressant de noter que les auteurs d'ALBERT n'ont pas eu à faire beaucoup de compromis sur la précision. +- ALBERT (*A Lite Bert*) : + Nous modifions BERT et le rendons plus léger en liant les poids entre les couches. Cela réduit les paramètres du modèle et les calculs impliqués. Il est intéressant de noter que les auteurs d'ALBERT n'ont pas eu à faire beaucoup de compromis sur la précision. - XLM : - - BERT multilingue : Au lieu d'alimenter un texte en anglais, nous alimentons un texte en plusieurs langues. Comme prévu, il a mieux appris les connexions interlinguistiques. + Il s'agit d'un BERT multilingue. Au lieu d'alimenter un texte en anglais, nous alimentons un texte en plusieurs langues. Comme prévu, il a mieux appris les connexions interlinguistiques. Les principaux enseignements tirés des différents modèles mentionnés ci-dessus sont les suivants : - De nombreux objectifs de pré-entraînement différents fonctionnent bien ! - - Il est essentiel de modéliser les interactions profondes et bidirectionnelles entre les mots - - Des gains importants grâce à l'intensification du pré-entraînement, sans encore de limites claires - -La plupart des modèles évoqués ci-dessus sont conçus pour résoudre le problème de la classification de textes. Cependant, pour résoudre le problème de la génération de texte, où nous générons les résultats de manière séquentielle comme le modèle "seq2seq", nous avons besoin d'une approche légèrement différente du pré-entraînement. +La plupart des modèles évoqués ci-dessus sont conçus pour résoudre le problème de la classification de textes. Cependant, pour résoudre le problème de la génération de texte, où nous générons les résultats de manière séquentielle comme le modèle *`seq2seq`, nous avons besoin d'une approche légèrement différente du pré-entraînement. -### Quelques questions ouvertes en PNL +### Quelques questions ouvertes en traitement du langage naturel -- Comment intégrer la connaissance du monde -- Comment modéliser les longs documents ? (Les modèles basés BERT utilisent généralement 512 tokens) -- Quelle est la meilleure façon de procéder pour l'apprentissage multitâche ? -- Pouvons-nous procéder à du fine-tuning avec moins de données ? +- Comment intégrer la connaissance du monde ? +- Comment modéliser de longs documents étant donné que les modèles basés sur BERT utilisent généralement seulement 512 jetons ? +- Quelle est la meilleure façon de procéder pour l'apprentissage multitâches ? +- Pouvons-nous procéder à du *finetuning* avec moins de données ? - Ces modèles comprennent-ils vraiment le langage ? -### Aperçu supplémentaire à partir des questions posées après le cours : +### Questions possées après le cours par des étudiants -Quels sont les moyens de quantifier la "compréhension du langage" ? Comment savons-nous que ces modèles sont réellement des modèles de compréhension du langage ? +**Quels sont les moyens de quantifier la compréhension du langage ? Comment savons-nous que ces modèles sont réellement des modèles de compréhension du langage ?** -"Le trophée ne rentrait pas dans la valise parce qu'il était trop grand" : Il est difficile pour les machines de résoudre le problème de la référence à "il" dans cette phrase. L'homme est doué pour cette tâche. Il existe un ensemble de données constitué d'exemples aussi difficiles et les humains ont atteint 95 % de performance sur cet ensemble de données. Les programmes informatiques n'atteignaient que 60% environ avant la révolution provoquée par les Transformers. Les modèles modernes de transformers sont capables d'atteindre plus de 90% sur cet ensemble de données. Cela suggère que ces modèles ne se contentent pas de mémoriser/exploiter les données, mais qu'ils apprennent des concepts et des objets grâce aux modèles statistiques des données. +> La phrase « mon trophée ne rentre pas dans mon bagage car il est trop grand » est difficile pour les modèles car ont des problèmes pour résoudre le problème de la référence à « il » dans cette phrase. L'homme est doué pour cette tâche. Il existe un jeu de données constitué d'exemples aussi difficiles et les humains atteigent 95 % de performance sur ce jeu de données. Les programmes informatiques n'atteignaient que 60% environ avant la révolution provoquée par les transformers. Les modèles modernes de transformers sont capables d'atteindre plus de 90%. Cela suggère que ces modèles ne se contentent pas de mémoriser/exploiter les données, mais qu'ils apprennent des concepts et des objets grâce aux modèles statistiques des données. +> En outre, BERT et RoBERTa atteignent des performances supérieures à celle humaine sur les jeux de donénes SQUAD et GLUE. Les résumés textuels générés par BART semblent très réels pour les humains (scores BLEU élevés). Ces faits sont la preuve que les modèles comprennent le langage d'une certaine manière. -En outre, BERT et RoBERTa atteignent des performances supérieures à l’humaine sur SQUAD et Glue. Les résumés textuels générés par BART semblent très réels pour les humains (scores BLEU élevés). Ces faits sont la preuve que les modèles comprennent le langage d'une certaine manière. -#### Langue de base - -Il est intéressant de noter que le conférencier (Mike Lewis, chercheur au FAIR) travaille sur un concept appelé "Grounded Language". L'objectif de ce domaine de recherche est de créer des agents conversationnels capables de bavarder ou de négocier. Le bavardage et la négociation sont des tâches abstraites dont les objectifs ne sont pas clairs par rapport à la classification ou au résumé de texte. +**Peut-on évaluer si le modèle a déjà une connaissance du monde ?** +> La connaissance du monde est un concept abstrait. Nous pouvons tester les modèles, au niveau le plus élémentaire en leur posant des questions simples sur les concepts qui nous intéressent. Des modèles comme BERT, RoBERTa et T5 ont des milliards de paramètres. Si l'on considère que ces modèles sont entraînés sur un énorme corpus de textes informationnels comme Wikipédia, ils mémorisent des faits en utilisant leurs paramètres et sont capables de répondre à nos questions. En outre, nous pouvons également envisager de réaliser le même test de connaissances avant et après le *finetuning* d'un modèle sur une tâche donnée. Cela nous donnerait une idée de la quantité d'informations que le modèle a « oubliées ». -#### Peut-on évaluer si le modèle a déjà une connaissance du monde ? -La "connaissance du monde" est un concept abstrait. Nous pouvons tester les modèles, au niveau le plus élémentaire en leur posant des questions simples sur les concepts qui nous intéressent. Des modèles comme BERT, RoBERTa et T5 ont des milliards de paramètres. Si l'on considère que ces modèles sont entraînés sur un énorme corpus de textes informationnels comme Wikipédia, ils auraient mémorisé des faits en utilisant leurs paramètres et seraient capables de répondre à nos questions. En outre, nous pouvons également envisager de réaliser le même test de connaissances avant et après la mise au point d'un modèle sur une tâche donnée. Cela nous donnerait une idée de la quantité d'informations que le modèle a "oubliées". +**Qu'est que le langage fondé sur la réalité (*grounded Language*) ?** +> L'objectif de ce domaine de recherche est de créer des agents conversationnels capables de bavarder ou de négocier. Le bavardage et la négociation sont des tâches abstraites dont les objectifs ne sont pas clairs par rapport à la classification ou au résumé de texte. diff --git a/docs/fr/week12/12-3.md b/docs/fr/week12/12-3.md index 418bfd33a..6a44c299c 100644 --- a/docs/fr/week12/12-3.md +++ b/docs/fr/week12/12-3.md @@ -20,9 +20,9 @@ As we will later see, transformers are made up of attention modules, which are m ## [Attention](https://www.youtube.com/watch?v=f01J0Dri-6k&t=69s) -Nous introduisons le concept d'attention avant de parler de l'architecture du Transformer. Il existe deux types principaux d'attention : l'auto-attention *vs.* l'attention croisée. Dans ces catégories, nous pouvons avoir une attention dure *vs.* une attention douce. +Nous introduisons le concept d'attention avant de parler de l'architecture du Transformer. Il existe deux types principaux d'attention : l'auto-attention vs l'attention croisée. Dans ces catégories, nous pouvons avoir une attention dure vs une attention douce. -Comme nous le verrons plus tard, les transformers sont constitués de modules d'attention, qui sont des mappages entre des ensembles (plutôt que des séquences), ce qui signifie que nous n'imposons pas d'ordre à nos entrées/sorties. +Comme nous le verrons plus tard, les transformers sont constitués de modules d'attention, qui sont des associations entre des ensembles (plutôt que des séquences), ce qui signifie que nous n'imposons pas d'ordre à nos entrées/sorties. @@ -93,7 +93,7 @@ With hard-attention, we impose the following constraint on the alphas: $\Vert\ve #### Attention dure -Avec beaucoup d'attention, nous imposons aux alphas la contrainte suivante : $\Vert\vect{a}\Vert_0 = 1$. Cela signifie que $\vect{a}$ est un vecteur one-hot. Par conséquent, tous les coefficients de la combinaison linéaire des entrées sauf un sont égaux à zéro, et la représentation cachée se réduit à l'entrée $\boldsymbol{x}_i$ correspondant à l'élément $\alpha_i=1$. +Avec beaucoup d'attention, nous imposons aux alphas la contrainte suivante : $\Vert\vect{a}\Vert_0 = 1$. Cela signifie que $\vect{a}$ est un vecteur *one-hot*. Par conséquent, tous les coefficients de la combinaison linéaire des entrées sauf un sont égaux à zéro, et la représentation cachée se réduit à l'entrée $\boldsymbol{x}_i$ correspondant à l'élément $\alpha_i=1$. -### Module Décodeur +### Module décodeur Le transformer-décodeur suit une procédure similaire à celle de l'encodeur. Cependant, il y a un sous-bloc supplémentaire à prendre en compte. De plus, les entrées de ce module sont différentes.

-Figure 4: Une explication plus amicale du décodeur. +Figure 4 : Une explication plus amicale du décodeur
@@ -541,7 +541,7 @@ Un ensemble, $\vect{x}\_1$ à $\vect{x}\_{t}$ est transmis par l'encodeur. En ut There are a few important facts we left out before to explain the most important modules of a transformer, but will need to discuss them now to understand how transformers can achieve state-of-art results in language tasks. --> -### Word Language Models +### Modèles du monde en linguistique Nous avons laissé de côté quelques faits importants pour expliquer les modules les plus importants d'un transformer, mais il faudra en discuter maintenant pour comprendre comment ils peuvent obtenir des résultats de pointe dans les tâches linguistiques. @@ -712,7 +712,7 @@ class Encoder(nn.Module): Nous allons maintenant voir les blocs du transformer dont nous avons parlé plus haut dans un format beaucoup plus compréhensible, le code ! -Dans le premier module, nous examinerons le bloc d'attention à plusieurs têtes. En fonction de la requête, de la clé et des valeurs entrées dans ce bloc, il peut être utilisé pour l'auto-attention ou l'attention croisée. +Dans le premier module, nous examinons le bloc d'attention à plusieurs têtes. En fonction de la requête, de la clé et des valeurs entrées dans ce bloc, il peut être utilisé pour l'auto-attention ou l'attention croisée. ```python class MultiHeadAttention(nn.Module): @@ -724,14 +724,14 @@ class MultiHeadAttention(nn.Module): d_xq = d_xk = d_xv = d_model else: d_xq, d_xk, d_xv = d_input - # Embedding dimension of model is a multiple of number of heads + # L'enchâssement de la dimension du model est un multiple du nombre de têtes assert d_model % self.num_heads == 0 self.d_k = d_model // self.num_heads - # These are still of dimension d_model. To split into number of heads + # Ceux-ci sont toujours de dimension d_model. Pour diviser en nombre de têtes self.W_q = nn.Linear(d_xq, d_model, bias=False) self.W_k = nn.Linear(d_xk, d_model, bias=False) self.W_v = nn.Linear(d_xv, d_model, bias=False) - # Outputs of all sub-layers need to be of dimension d_model + # Les sorties de tous les sous-couches doivent être de dimension d_model. self.W_h = nn.Linear(d_model, d_model) ``` @@ -742,13 +742,13 @@ def scaled_dot_product_attention(self, Q, K, V): batch_size = Q.size(0) k_length = K.size(-2) - # Scaling by d_k so that the soft(arg)max doesnt saturate + Mise à l'échelle par d_k pour que le soft(arg)max ne sature pas Q = Q / np.sqrt(self.d_k) # (bs, n_heads, q_length, dim_per_head) scores = torch.matmul(Q, K.transpose(2,3)) # (bs, n_heads, q_length, k_length) A = nn_Softargmax(dim=-1)(scores) # (bs, n_heads, q_length, k_length) - # Get the weighted average of the values + # Donne la moyenne pondérée des valeurs H = torch.matmul(A, V) # (bs, n_heads, q_length, dim_per_head) return H, A @@ -774,15 +774,15 @@ Combine les têtes d'attention ensemble, pour obtenir une forme correcte conform ```python def forward(self, X_q, X_k, X_v): batch_size, seq_length, dim = X_q.size() - # After transforming, split into num_heads + # Après la transformation, divise en num_heads Q = self.split_heads(self.W_q(X_q), batch_size) K = self.split_heads(self.W_k(X_k), batch_size) V = self.split_heads(self.W_v(X_v), batch_size) - # Calculate the attention weights for each of the heads + # Calcule les poids d'attention pour chacune des têtes H_cat, A = self.scaled_dot_product_attention(Q, K, V) - # Put all the heads back together by concat + # Remettre toutes les têtes ensemble par concaténation H_cat = self.group_heads(H_cat, batch_size) # (bs, q_length, dim) - # Final linear layer + # Couche linéaire finale H = self.W_h(H_cat) # (bs, q_length, dim) return H, A ``` @@ -821,11 +821,10 @@ E(p, 2i+1) &= \cos(p / 10000^{2i / d}) \end{aligned} $$ -Pour ne pas trop s'attarder sur les détails, nous vous renvoyons à (là)[https://github.com/Atcold/pytorch-Deep-Learning/blob/master/15-transformer.ipynb] pour le code complet utilisé ici. - +Pour ne pas trop s'attarder sur les détails, nous vous renvoyons au *notebook* pour le code complet utilisé. Il est disponible en anglais [ici](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/15-transformer.ipynb) et en français [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/15-transformer.ipynb). -Un encodeur complet, avec N couches d'encodeur empilées, ainsi que des encastrements de position, s'écrit +Un encodeur complet, avec N couches d'encodeur empilées, ainsi que des encastrements de position, s'écrit : ```python class Encoder(nn.Module): @@ -869,10 +868,11 @@ Where this model is trained in typical fashion. --> ## Exemple d'utilisation + Il y a beaucoup de tâches pour lesquelles vous pouvez utiliser un simple encodeur. Dans le notebook d'accompagnement, nous voyons comment un encodeur peut être utilisé pour l'analyse des sentiments. -En utilisant l'ensemble de données d'Imdb (l’équivalent anglophone d’AlloCiné), nous pouvons sortir de l'encodeur une représentation latente d'une séquence de texte, et entraîner ce processus d'encodage avec une entropie croisée binaire, correspondant à une revue de film positive ou négative. -Là encore, nous laissons de côté les écrous et les boulons, et nous vous dirigeons vers le bloc-notes, mais voici les principaux composants architecturaux utilisés dans le transformateur : +En utilisant le jeu de données d'IMDB (l’équivalent anglophone d’AlloCiné), nous pouvons sortir de l'encodeur une représentation latente d'une séquence de text, et entraîner ce processus d'encodage avec une entropie croisée binaire, correspondant à une critique de film positive ou négative. +Là encore, nous laissons de côté les dessous techniques et nous vous dirigeons vers le *notebook*, mais voici les principaux composants architecturaux utilisés dans le transformateur : ```python class TransformerClassifier(nn.Module): def forward(self, x): diff --git a/docs/fr/week12/12.md b/docs/fr/week12/12.md index ea29a2cac..8e9b5c1c2 100644 --- a/docs/fr/week12/12.md +++ b/docs/fr/week12/12.md @@ -14,9 +14,9 @@ In this section we discuss the various architectures used in NLP applications, b --> -## Conférence partie A +## Cours magistral partie A -Dans cette section, nous discutons des différentes architectures utilisées dans les applications de NLP, en commençant par les ConvNets, les RNN, et en couvrant finalement l'architecture de pointe, les transformers. Nous abordons ensuite les différents modules qui composent les transformers et comment ils rendent les transformers avantageux pour les tâches de NLP. Enfin, nous discutons des astuces qui permettent d’entraîner efficacement les transformers. +Dans cette section, nous discutons des différentes architectures utilisées dans les applications de traitement du langage naturel, en commençant par les ConvNets, les RNNs et en couvrant finalement l'architecture de pointe, les transformers. Nous abordons ensuite les différents modules qui composent les transformers et comment ils rendent avantageux cette architecture pour les tâches de texte. Enfin, nous discutons des astuces qui permettent d’entraîner efficacement les transformers. -## Conférence partie B +## Cours magistral partie B -Dans cette section, nous présentons la recherche par faisceau comme un consensus entre le décodage gourmand et la recherche exhaustive. Nous considérons le cas de vouloir échantillonner à partir de la distribution générative (c'est-à-dire lors de la génération de texte) et introduisons l'échantillonnage "top-k". Ensuite, nous introduisons les modèles de séquence à séquence (avec une variante pours les transformers) et la rétro-traduction. Nous introduisons ensuite des approches d'apprentissage non supervisées pour l'apprentissage des embeddings et discutons de word2vec, GPT et BERT. +Dans cette section, nous présentons la recherche en faisceau comme un consensus entre le décodage gourmand et la recherche exhaustive. Nous considérons le cas de vouloir échantillonner à partir de la distribution générative (c'est-à-dire lors de la génération de texte) et introduisons l'échantillonnage *top-k*. Ensuite, nous introduisons les modèles de séquence à séquence (avec une variante pour les transformers) et la rétro-traduction. Nous voyons enfin des approches d'apprentissage non supervisées pour l'apprentissage des enchâssements et discutons de word2vec, GPT et BERT. -## Pratique -Nous introduisons l'attention, en nous concentrant sur l'auto-attention et ses représentations en couches cachées des intrants. Ensuite, nous introduisons le paradigme des valeurs des clés et discutons de la manière de représenter les requêtes, les clés et les valeurs comme des rotations d'une entrée. Enfin, nous utilisons l'attention pour interpréter l'architecture du transformer, en prenant un passage en avant à travers un transformer de base. Enfin nous comparons le paradigme de l'encodeur-décodeur à celui des architectures séquentielles. - - - - +## Travaux dirigés +Nous introduisons l'attention, en nous concentrant sur l'auto-attention et ses représentations de couches cachées des entrées. Ensuite, nous abordons le paradigme des valeurs des clés et discutons de la manière de représenter les requêtes, les clés et les valeurs comme des rotations d'une entrée. Enfin, nous utilisons l'attention pour interpréter l'architecture du transformer, en prenant une propagation avant à travers un transformer de base. Enfin nous comparons le paradigme de l'encodeur-décodeur à celui des architectures séquentielles. diff --git a/docs/fr/week13/13-1.md b/docs/fr/week13/13-1.md index daf3dc9a2..838346560 100644 --- a/docs/fr/week13/13-1.md +++ b/docs/fr/week13/13-1.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.13-1 -title: Réseau convolutif sur graphe (Graph Convolutional Network (GCN)) I +title: Réseau convolutif pour graphe I lecturer: Xavier Bresson authors: Bilal Munawar, Alexander Bienstock, Can Cui, Shaoling Chen date: 27 Apr 2020 @@ -36,14 +36,14 @@ Consider an image of 1024 x 1024 pixels. This image can be seen as a point in th ### Qu'est-ce que la malédiction de la dimensionnalité ? -Considérons une image de 1024 x 1024 pixels. Cette image peut être considérée comme un point dans l'espace pour 1 000 000 de dimensions. L'utilisation de 10 échantillons par dimension génère des images de ${10}^{1.000.000}$, ce qui est extrêmement élevé. Les réseaux convolutifs sont extrêmement puissants pour extraire la meilleure représentation des données d'images à haute dimension, comme celle donnée dans l'exemple. +Considérons une image de 1024 x 1024 pixels. Cette image peut être considérée comme un point dans l'espace pour 1 000 000 de dimensions. L'utilisation de 10 échantillons par dimension génère des images de ${10}^{1 000 000}$, ce qui est extrêmement élevé. Les réseaux convolutifs sont extrêmement puissants pour extraire la meilleure représentation des données d'images à haute dimension, comme celle donnée dans l'exemple. - dim(image) = **1024 x 1024** = ${10}^{6}$ -- Pour **N = 10** échantillons/dim => **${10}^{1,000,000}$ points** +- Pour **N = 10** échantillons/dim => **${10}^{1 000 000}$ points**

-Figure 1 : Les réseaux convolutifs extraient la représentation des données d'images en haute dimension. +Figure 1 : Les réseaux convolutifs extraient la représentation des données d'images en haute dimension
@@ -79,22 +79,22 @@ They extract compositional features and feed them to classifier, recommender, et Elles sont formées de motifs qui sont : -* **Locaux** Un neurone du réseau neuronal n'est connecté qu'aux couches adjacentes, mais pas à toutes les couches du réseau. C'est ce que nous appelons l'hypothèse du champ de réception local. -* **Stationnaires** Nous avons des motifs qui sont similaires et qui sont partagés dans tout notre domaine d'image. Par exemple, le drap de lit jaune dans l'image du milieu de la figure 2. -* **Hierarchiques** Les caractéristiques de bas niveau seront combinées pour former des caractéristiques de niveau moyen. Par la suite, ces éléments de niveau moyen seront combinés pour former progressivement des éléments de niveau supérieur. Par exemple, une représentation visuelle. +* **Locaux** : un neurone du réseau neuronal n'est connecté qu'aux couches adjacentes, mais pas à toutes les couches du réseau. C'est ce que nous appelons l'hypothèse du champ de réception local. +* **Stationnaires** : nous avons des motifs qui sont similaires et qui sont partagés dans tout notre domaine d'image. Par exemple, le drap de lit jaune dans l'image du milieu de la figure 2. +* **Hierarchiques** : les caractéristiques de bas niveau seront combinées pour former des caractéristiques de niveau moyen. Par la suite, ces éléments de niveau moyen seront combinés pour former progressivement des éléments de niveau supérieur. Par exemple, une représentation visuelle.

-Figure 2 : Les données sont compositionnelles. +Figure 2< :/b> Les données sont compositionnelles
-**2. Les réseaux convolutifs tirent parti de la structure de composition.** +**2. Les réseaux convolutifs tirent parti de la compositionnalité de la structure.** -Ils extraient les caractéristiques de composition et les transmettent au classifieur, au recommandeur, etc… +Ils extraient les caractéristiques de composition et les transmettent au classifieur, au recommandeur, etc.

-Figure 3 : Les réseaux convolutifs tirent parti de la structure de composition. +Figure 3 : : Les réseaux convolutifs tirent parti de la compositionnalité de la structure
@@ -138,30 +138,30 @@ Ils extraient les caractéristiques de composition et les transmettent au classi

-Fig. 4 : Les images ont de multiples dimensions. +Figure 4 : Les images ont de multiples dimensions
* Les phrases, les mots, la parole se trouvent sur le domaine euclidien 1D. Par exemple, chaque caractère peut être représenté par un entier. -
-
- Fig. 5 : Les séquences ont une seule dimension. -
+
+
+Figure 5 : Les séquences ont une seule dimension +
* Ces domaines ont de fortes structures spatiales régulières, ce qui permet à toutes les opérations des réseaux convolutifs d'être rapides et mathématiquement bien définies. -
-
- Fig. 6 : Les données vocales ont une grille 1D. -
+
+
+Figure 6< :/b> Les données vocales ont une grille 1D +
-### Domaine du graphes +### Domaine du graphe -### Pouvons-nous étendre la correspondance des modèles pour les graphes ? +### Pouvons-nous étendre l'appariement de patrons aux graphes ? Nous avons quelques problèmes : 1. Premièrement, dans un graphe, il n'y a pas d'ordre des nœuds. -Ainsi, dans le modèle montré ci-dessous dans l'image, le nœud $j_3$ n'a pas de position spécifique, mais juste un index (arbitraire). -Ainsi, lorsque nous essayons de faire correspondre les nœuds $i$ et $i'$ dans le graphique ci-dessous, nous ne savons pas si $j_3$ correspond aux mêmes nœuds dans les deux convolutions. -Ceci est dû au fait qu'il n'y a pas de notion de *coin supérieur droit* du graphique. +Ainsi, dans l'image, le nœud $j_3$ n'a pas de position spécifique, mais juste un index (arbitraire). +Ainsi, lorsque nous essayons de faire correspondre les nœuds $i$ et $i'$ dans le graphe ci-dessous, nous ne savons pas si $j_3$ correspond aux mêmes nœuds dans les deux convolutions. +Ceci est dû au fait qu'il n'y a pas de notion de *coin supérieur droit* dans le graphe. Il n'y a pas de notion de haut, bas, gauche droite. -Ainsi, les correspondances de modèles n'ont en fait aucune signification et nous ne pouvons pas utiliser la définition de correspondance de modèle directement, comme ci-dessus. +Ainsi, l'appariement de patrons n'a en fait aucune signification et nous ne pouvons pas l'utiliser directement comme ci-dessus.

-Fig. 14 : Pas de classement des nœuds dans un graphe. +Figure 14 : Pas d'ordre des nœuds dans un graphe
2. Le deuxième problème est que la taille du voisinage peut être différente. Ainsi, le modèle $w^\ell$ présenté ci-dessous a 4 nœuds, mais le nœud $i$ a 7 nœuds dans son voisinage. -Comment pouvons-nous comparer ces deux modèles ? +Comment pouvons-nous comparer ces deux choses ?

-Fig. 15 : Différentes tailles de voisinage dans un graphe. +Figure 15 : Différentes tailles de voisinage dans un graphe
-## Convolution du graphe +## Convolution pour un graphe Nous utilisons maintenant le **théorème des convolutions** pour définir les convolutions des graphes. -Le **théorème des convolutions** indique que la transformée de Fourier (FFT) de la convolution de deux fonctions est le produit ponctuel de leurs transformées de Fourier : +Le **théorème des convolutions** indique que la transformée de Fourier (FFT) de la convolution de deux fonctions est le produit élément par élément de leurs transformées de Fourier : $$\mathcal{F}(w*h) = \mathcal{F}(w) \odot \mathcal{F}(h) \implies w * h = \mathcal{F}^{-1}(\mathcal{F}(w)\odot\mathcal{F}(h))$$ @@ -505,12 +505,11 @@ Template matching will be for spacial graph ConvNets and the Convolution theorem Cela soulève deux questions : 1. Comment définir les transformées de Fourier pour les graphes ? -2. Comment calculer des convolutions spectrales rapides en temps $O(n)$ pour les noyaux compacts (comme dans la correspondance des modèles) ? +2. Comment calculer des convolutions spectrales rapides en temps $O(n)$ pour les noyaux compacts (comme dans l'appariement de patrons) ? $$w *_{\mathcal{G}} h \stackrel{?}{=} \mathcal{F}^{-1}_{\mathcal{G}}(\mathcal{F}_{\mathcal{G}}(w)\odot\mathcal{F}_{\mathcal{G}}(h))$$ -Nous allons utiliser ces deux modèles pour les réseaux neuronaux de graphes : -La correspondance des modèles sera utilisée pour les réseaux convolutifs de graphes spatiaux et le théorème de convolution sera utilisé pour les réseaux convolutifs spectraux. +Nous allons utiliser ces deux modèles pour les réseaux neuronaux de graphes. L'appariement de patrons sera utilisé pour les GCNs (ConvNets pour graphe) spatiaux et le théorème de convolution sera utilisé pour les GCNs spectraux. -## [Réseau convolutif spectral sur graphe](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=1529s) +## [GCNs spectraux](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=1529s) Comment effectuer une convolution spectrale ? @@ -557,7 +556,7 @@ $$ $$ -Note Matrice $A$ est la matrice de contiguïté, et le $\Delta$ est le Laplacien, qui est égal à l'identité moins la matrice de contiguïté normalisée par la matrice $D$. $D$ est une matrice diagonale, et chaque élément de la diagonale est le degré du nœud. C'est ce qu'on appelle le Laplacien normalisé, ou Laplacien par défaut dans ce contexte. +$A$ est la matrice d'adjacence et le $\Delta$ est le Laplacien, qui est égal à l'identité moins la matrice d'adjacence normalisée par la matrice $D$. $D$ est une matrice diagonale et chaque élément de la diagonale est le degré du nœud. C'est ce qu'on appelle le Laplacien normalisé ou simplement Laplacien par défaut dans ce contexte. Le Laplacien est interprété comme la mesure de la finesse du graphe, en d'autres termes, la différence entre la valeur locale $h_i$ et sa valeur moyenne de voisinage de $h_j$'s. $d_i$ sur la formule ci-dessous est le degré du nœud $i$, et $\mathcal{N}_{i}$ est l'ensemble des voisins du nœud $i$. @@ -566,7 +565,7 @@ $$ (\Delta h)_{i}=h_{i}-\frac{1}{d_{i}} \sum_{j \in \mathcal{N}_{i}} A_{i j} h_{j} $$ -La formule ci-dessus consiste à appliquer le Laplacien à une fonction $h$ sur le nœud $i$, qui est la valeur de $h_i$ moins la valeur moyenne sur ses nœuds voisins $h_j$. Fondamentalement, si le signal est très lisse, la valeur de Laplacien est faible, et *vice versa*. +La formule ci-dessus consiste à appliquer le Laplacien à une fonction $h$ sur le nœud $i$, qui est la valeur de $h_i$ moins la valeur moyenne sur ses nœuds voisins $h_j$. Fondamentalement, si le signal est très lisse, la valeur de Laplacien est faible et *vice versa*. -## [Réseau convolutif spectral sur graphe](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=2670s) +## [Réseaux convolutifs pour graphe (GCNs) spectraux](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=2670s) -Dans la section précédente, nous avons discuté de la théorie spectrale des graphes, l'une des deux façons de définir la convolution des graphes, que nous pouvons maintenant utiliser pour définir les GCN spectraux. +Dans la section précédente, nous avons discuté de la théorie spectrale des graphes et de l'une des deux façons de définir la convolution des graphes que nous pouvons maintenant utiliser pour définir les GCNs spectraux. -### Réseau convolutif spectral sur graphe ordinaire +### GCN spectral standard -Nous définissons une couche convolutionnelle spectrale sur graphe telle que, étant donné la couche $h^l$, l'activation de la couche suivante est : +Nous définissons une couche convolutionnelle spectrale pour graphe telle que, étant donnée la couche $h^l$, l'activation de la couche suivante est : $$ h^{l+1}=\eta(w^l*h^l), $$ -où $\eta$ représente une activation non linéaire et $w^l$ est un filtre spatial. L’RHS de l'équation est équivalente à $\eta(\hat{w}^l(\Delta)h^l)$ où $\hat{w}^l$ représente un filtre spectral et $\Delta$ est le laplacien. Nous pouvons ensuite décomposer l’RHS de l'équation en $\eta(\boldsymbol{\phi} \hat{w}^l(\Lambda)\boldsymbol{\phi^\top} h^l)$, où $\boldsymbol{\phi}$ est la matrice de Fourier et $\Lambda$ sont les valeurs propres. On obtient ainsi l'équation d'activation finale suivante. +où $\eta$ représente une activation non linéaire et $w^l$ est un filtre spatial. Le côté droit de l'équation est équivalent à $\eta(\hat{w}^l(\Delta)h^l)$ où $\hat{w}^l$ représente un filtre spectral et $\Delta$ est le laplacien. Nous pouvons ensuite décomposer le côté droit de l'équation en $\eta(\boldsymbol{\phi} \hat{w}^l(\Lambda)\boldsymbol{\phi^\top} h^l)$, où $\boldsymbol{\phi}$ est la matrice de Fourier et $\Lambda$ sont les valeurs propres. On obtient ainsi l'équation d'activation finale suivante. $$ h^{l+1}=\eta\Big(\boldsymbol{\phi} \hat{w}^l(\Lambda)\boldsymbol{\phi^\top} h^l\Big) @@ -59,9 +59,9 @@ $$ L'objectif est d'apprendre le filtre spectral $\hat{w}^l(\lambda)$ en utilisant la rétropropagation au lieu de la conception manuelle. Cette technique a été la première technique spectrale utilisée pour les ConvNets, mais elle présente quelques limites : -* Aucune garantie de localisation spatiale des filtres -* Besoin d'apprendre les paramètres $O(n)$ par couche ($\hat{w}(\lambda_1)$ à $\hat{w}(\lambda_n)$) -* Le taux d'apprentissage est de $O(n^2$) car $\boldsymbol{\phi}$ est une matrice dense +* Aucune garantie de localisation spatiale des filtres. +* Besoin d'apprendre les paramètres $O(n)$ par couche ($\hat{w}(\lambda_1)$ à $\hat{w}(\lambda_n)$). +* Le taux d'apprentissage est de $O(n^2$) car $\boldsymbol{\phi}$ est une matrice dense. -## [Réseau convolutif sur graphe spacial](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=3964s) +## [GCNs spaciaux](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=3964s) -### Template matching +### Appariement de patrons -Pour comprendre les réseaux convolutifs sur graphe spaciaux, nous revenons à la définition des ConvNets dans le template matching. +Pour comprendre les CGNs spaciaux, nous revenons à la définition des ConvNets via l'appariement de patrons. -Le problème principal lorsque nous effectuons la comparaison de modèles pour les graphes est l'absence d'ordre ou de positionnement des nœuds pour le modèle. Tout ce que nous avons, ce sont les indices des nœuds, ce qui ne suffit pas pour faire correspondre les informations entre eux. Comment pouvons-nous concevoir la mise en correspondance des modèles de manière à ce qu'elle soit invariante pour le re-paramétrage des nœuds ? C'est-à-dire que si nous avons un graphe et que l'un des nœuds avait un indice arbitraire, disons 6, cet indice aurait pu être de 122 également. Il est donc essentiel de pouvoir effectuer la correspondance des modèles indépendamment de l'index du nœud. +Le problème principal lorsque nous effectuons l'appariement de patrons pour les graphes est l'absence d'ordre ou de positionnement des nœuds pour le modèle. Tout ce que nous avons, ce sont les indices des nœuds, ce qui ne suffit pas pour faire correspondre les informations entre eux. Comment pouvons-nous concevoir l'appariement de patrons de manière à ce qu'il soit invariant pour le reparamétrage des nœuds ? C'est-à-dire pas de modification si nous avons un graphe et changeons l'indice arbitraire de l'un des nœuds de, disons 6, à 122. Il est donc essentiel de pouvoir effectuer l'appariement de patrons indépendamment de l'index du nœud. -La façon la plus simple de le faire est d'avoir un seul vecteur de modèle $w^l$, au lieu d'avoir $w_{j1}$, $w_{j2}$, $w_{j3}$ ou ainsi de suite. Nous faisons donc correspondre ce vecteur $w^l$ avec toutes les autres caractéristiques de notre graphe. La plupart des réseaux neuronaux de graphes utilisent aujourd'hui cette propriété. +La façon la plus simple de le faire est d'avoir un seul vecteur de patron $w^l$, au lieu d'avoir $w_{j1}$, $w_{j2}$, $w_{j3}$ ou ainsi de suite. Nous faisons donc correspondre ce vecteur $w^l$ avec toutes les autres caractéristiques de notre graphe. La plupart des GNNs utilisent aujourd'hui cette propriété.

-Figure 2: Correspondance de modèles à l'aide d'un vecteur de modèle +Figure 2 : L'appariement de patrons à l'aide d'un vecteur de patron
Mathématiquement, pour une caractéristique que nous avons, $$h_{i}^{l+1}=\eta\bigg(\sum_{j \in N_{i}} \langle w^l,h_{ij}^l \rangle \bigg)$$ -où $w^l$ est le vecteur modèle au niveau de la couche $l$ de dimensions $d \times 1$ et $h_{ij}^l$ est le vecteur au niveau du noeud j avec $d \times 1$ ce qui donnera une quantité d'échelle $h_{i}^{l+1}$ au noeud $i$. +où $w^l$ est le vecteur de patron au niveau de la couche $l$ de dimensions $d \times 1$ et $h_{ij}^l$ est le vecteur au niveau du noeud j avec $d \times 1$ ce qui donnera une quantité d'échelle $h_{i}^{l+1}$ au noeud $i$. Pour plus de ($d$) caractéristiques, @@ -289,9 +289,9 @@ Pour une représentation vectorielle, $$h^{l+1}=\eta(\boldsymbol{A} h^l \boldsymbol{W}^l)$$ -où $\boldsymbol{A}$ est la matrice de contiguïté de dimensions $n \times n$, $h^l$ est la fonction d'activation à la couche $l$ de dimensions $n \times d$. +où $\boldsymbol{A}$ est la matrice d'adjacence de dimensions $n \times n$, $h^l$ est la fonction d'activation à la couche $l$ de dimensions $n \times d$. -Sur la base de cette définition de la correspondance des modèles, nous pouvons définir deux types de GSN spatiaux : les GCN isotropes et les GCN anisotropes. +Sur la base de cette définition de l'appariement de patrons, nous pouvons définir deux types de GCNs spatiaux : les GCNs isotropes et les GCNs anisotropes. -### GCNs spaciaux ordinaires +### GCNs spaciaux standards -Elle a la même définition qu'auparavant, mais nous ajoutons la matrice diagonale dans l'équation, de telle sorte que nous trouvons la valeur moyenne du quartier. +Même définition qu'auparavant, mais nous ajoutons la matrice diagonale dans l'équation, de telle sorte que nous trouvons la valeur moyenne du voisinnage. -La représentation matricielle étant, +La représentation matricielle étant : $$h^{l+1} = \eta(\boldsymbol{D}^{-1}\boldsymbol{A}h^{l}\boldsymbol{W}^{l})$$ @@ -355,7 +355,7 @@ $$h_{i}^{l+1} = \eta\bigg(\frac{1}{d_{i}}\sum_{j \in N_{i}}\boldsymbol{A}_{ij}\b où, $h_{i}^{l+1}$ a les dimensions de $d \times 1$ -La représentation vectorielle est responsable de la gestion de l'absence d'ordonnancement des nœuds, qui est invariante de la re-paramétrisation des nœuds. C'est-à-dire, en ajoutant à l'exemple précédent, si le noeud a un en 6 et est changé en 122, cela ne changera rien dans le calcul de la fonction d'activation de la couche suivante $h^{l+1}$. +La représentation vectorielle est responsable de la gestion de l'absence d'ordonnancement des nœuds, qui est invariante de la reparamétrisation des nœuds. C'est-à-dire, en ajoutant à l'exemple précédent, si le noeud a un en 6 et est changé en 122, cela ne changera rien dans le calcul de la fonction d'activation de la couche suivante $h^{l+1}$. Nous pouvons également traiter des voisinages de tailles différentes. C'est-à-dire que nous pouvons avoir un voisinage de 4 nœuds ou de 10 nœuds, cela ne changera rien. @@ -369,7 +369,7 @@ Comme il s'agit d'un modèle isotrope, les voisins auront la même matrice $\bol

-Figure 3: Modèle isotrope +Figure 3 : Modèle isotrope
$$h_{i}^{l+1} = f_\text{GCN}(h_{i}^{l}, \{h_{j}^l: j \rightarrow i\})$$ @@ -384,9 +384,9 @@ The above defined Vanilla Spatial GCN is a simplification of ChebNets. We can tr $$h_{i}^{l+1} = \eta\bigg(\frac{1}{\hat{d_{i}}}\sum_{j \in N_{i}}\hat{\boldsymbol{A}_{ij}}\boldsymbol{W}^{l}h_{j}^{l}\bigg)$$ --> -### ChebNets et GCNs spaciaux ordinaires +### ChebNets et GCNs spaciaux standards -Le GCN spatial ordinaire défini ci-dessus est une simplification des ChebNets. Nous pouvons tronquer l'expansion de ChebNet en utilisant les deux premières fonctions de Chebyshev pour aboutir, +Le GCN spatial standard défini ci-dessus est une simplification des ChebNets. Nous pouvons tronquer l'expansion de ChebNet en utilisant les deux premières fonctions de Chebyshev pour aboutir à : $$h_{i}^{l+1} = \eta\bigg(\frac{1}{\hat{d_{i}}}\sum_{j \in N_{i}}\hat{\boldsymbol{A}_{ij}}\boldsymbol{W}^{l}h_{j}^{l}\bigg)$$ @@ -414,11 +414,11 @@ In this equation, we can find the summation or maximum of $\boldsymbol{W}\_{2}^{ ### GraphSage -Si la matrice d'adjacence $\boldsymbol{A}_{ij} = 1$ pour les arêtes dans les GCN Vanilla Spatial, on obtient, +Si la matrice d'adjacence $\boldsymbol{A}_{ij} = 1$ pour les arêtes dans les GCNs spatiaux standards, on obtient : $$h_{i}^{l+1} = \eta\bigg(\frac{1}{d_{i}}\sum_{j \in N_{i}}\boldsymbol{W}^{l}h_{j}^{l}\bigg)$$ -Pour cette équation, nous donnons au sommet central/coeur $i$ et à son voisinage le même poids de modèle $\boldsymbol{W}^{l}$. Nous pouvons différencier cette équation en donnant au nœud central $\boldsymbol{W}\_{1}^{l}$, et en ayant un nœud de modèle différent $\boldsymbol{W}_{2}^{l}$ pour le quartier chaud. Cela permettra d'améliorer considérablement les performances des GNN. Ce modèle est toujours considéré comme étant de nature isotrope, puisque les voisins ont le même poids. +Pour cette équation, nous donnons au sommet central/coeur $i$ et à son voisinage le même poids au pochoir $\boldsymbol{W}^{l}$. Nous pouvons différencier cette équation en donnant au nœud central $\boldsymbol{W}\_{1}^{l}$, et en ayant un nœud de pochoir différent $\boldsymbol{W}_{2}^{l}$ pour le voisinage *one-hot*. Cela permettra d'améliorer considérablement les performances des GNNs. Ce modèle est toujours considéré comme étant de nature isotrope, puisque les voisins ont le même poids. $$h_{i}^{l+1} = \eta\bigg(\boldsymbol{W}_{1}^{l} h_{i}^{l} + \frac{1}{d_{i}} \sum_{j \in N_{i}} \boldsymbol{W}_{2}^{l} h_{j}^{l}\bigg)$$ @@ -428,7 +428,7 @@ Dans cette équation, on peut trouver la somme ou le maximum de $\boldsymbol{W}\

-Figure 4: GraphSage +Figure 4 : GraphSage
-### Graph Isomorphism Networks (GIN) +### *Graph Isomorphism Networks* (GIN) Une architecture qui peut différencier les graphes qui ne sont pas isomorphiques. *L'isomorphisme* est la mesure de l'équivalence entre les graphes. Dans la figure ci-dessous, les deux graphes sont considérés comme isomorphes l'un par rapport à l'autre. Les graphes isomorphes seront traités de manière similaire et les graphes non isomorphes seront traités différemment. -Le GIN est un GCN isotrope. +Le GIN (*Graph Isomorphism Networks*) est un GCN isotrope. $$h_{i}^{l+1} = \texttt{ReLU}(\boldsymbol{W}_{2}^{l}\space \texttt{ReLU}(\texttt{BN}(\boldsymbol{W}_{1}^{l} \hat(h_{j}^{l+1})))$$ -où, $\texttt{BN}$ représente la batch normalisation. +où, $\texttt{BN}$ représente la normalisation par batch. $$h_{i}^{l+1} = (1 + \epsilon)h_{i}^{l} + \sum_{j \in N_{i}} h_{j}^{l}$$

-Figure 5: Exemples de deux graphes isomorphes +Figure 5 : Exemples de deux graphes isomorphes
-## [Anisotropic GCNs](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=5586s) - +## [GCNs anisotropes](https://www.youtube.com/watch?v=Iiv9R6BjxHM&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=24&t=5586s) Les ConvNets standards ont la capacité de produire des filtres anisotropes qui favorisent certaines directions. En effet, la structure directionnelle est basée sur le haut, le bas, la gauche et la droite. Cependant les ConvNets décrits ci-dessus n'ont aucune notion de direction, et ne peuvent donc produire que des filtres isotropes. L'anisotropie peut être introduite naturellement, avec des caractéristiques d’arêtes. Par exemple, les molécules peuvent avoir des liaisons simples, doubles et triples. Graphiquement, elle est introduite en pondérant différemment les différents voisins. @@ -492,11 +491,11 @@ MoNets use the degree of the graph to learn the parameters of a Gaussian Mixture ### MoNets -Les MoNets utilisent le degré du graphe pour apprendre les paramètres d'un modèle de mélange gaussien (MGM). +Les MoNets utilisent le degré du graphe pour apprendre les paramètres d'un modèle de mélange gaussien.

-Figure 6: MoNet +Figure 6 : MoNet
@@ -511,13 +510,13 @@ GAT uses the attention mechanism to introduce anisotropy in the neighbourhood ag
--> -### Réseau à graphe d'attention (Graph Attention Networks : GAT) +### *Graph Attention Networks* (GATs) Le GAT utilise le mécanisme d'attention pour introduire l'anisotropie dans la fonction d'agrégation du voisinage.

-Figure 7: GAT +Figure 7 : GAT
-### Réseau à rupteur convolutif sur graphe +### GCNs à porte -Celles-ci utilisent un simple mécanisme de porte. Cela peut être considéré comme un processus d'attention plus doux que le mécanisme d'attention épars utilisé dans les GATs. +Ils utilisent un simple mécanisme de porte. Cela peut être considéré comme un processus d'attention plus doux que le mécanisme d'attention épars utilisé dans les GATs.

-Figure 8: Gated Graph ConvNet +Figure 8 : GCNs à porte
@@ -554,16 +553,16 @@ This is the graph version of the standard transformer, commonly used in NLP. If Graphs obtain their structure from sparsity, so the fully connected graph has trivial structure and is essentially a set. Transformers then can be viewed as **Set** Neural Networks, and are in fact the best technique currently to analyse sets/bags of features. --> -### Graph Transformers +### *Graph Transformers*

-Figure 9: Graph Transformer +Figure 9 : Graph Transformer
-Il s'agit de la version graphique du Transformer standard communément utilisé en NLP. Si le graphe est entièrement connecté (tous les deux nœuds partagent une arête), on retrouve la définition d'un transformer standard. +Il s'agit de la version sous la forme d'un graphe du transformer standard communément utilisé en traitement du langage naturel. Si le graphe est entièrement connecté (tous les deux nœuds partagent une arête), on retrouve la définition d'un transformer standard. -Les graphes obtiennent leur structure à partir d'une éparsité, donc le graphe entièrement connecté a une structure triviale et est essentiellement un ensemble. Les transformers peuvent alors être considérés comme des réseaux de neurones **Set**, et sont en fait la meilleure technique actuelle pour analyser des ensembles/sacs de caractéristiques. +Les graphes obtiennent leur structure à partir d'une éparsité, donc le graphe entièrement connecté a une structure triviale et est essentiellement un ensemble. Les transformers peuvent alors être considérés comme des réseaux de neurones **Set** et sont en fait la meilleure technique actuelle pour analyser des ensembles de caractéristiques. -## Analyse comparative des GNN +## Analyse comparative des GNNs -Les critères de référence sont un élément essentiel du progrès dans tout domaine. Le benchmark récemment publié [Benchmarking Graph Neural Networks](https://arxiv.org/pdf/2003.00982.pdf/) comporte six ensembles de données à moyenne échelle qui peuvent être utilisés pour quatre problèmes fondamentaux des graphes : la classification des graphes, la régression des graphes, la classification des nœuds et la classification des arêtes. Bien que ces ensembles de données soient de taille moyenne, ils sont suffisants pour séparer statiquement les tendances des différents réseaux de neurones des graphes. +Les critères de référence sont un élément essentiel du progrès dans tout domaine. Le benchmark récemment publié [Benchmarking Graph Neural Networks](https://arxiv.org/pdf/2003.00982.pdf/) comporte six jeux de données à moyenne échelle qui peuvent être utilisés pour quatre problèmes fondamentaux des graphes : la classification de graphes, la régression de graphes, la classification des nœuds et la classification des arêtes. Bien que ces jeux de données soient de taille moyenne, ils sont suffisants pour séparer statiquement les tendances des différents réseaux de neurones des graphes. -À titre d'exemple de **tâche de régression de graphe**, nous voudrions prédire la solubilité moléculaire. +À titre d'exemple de **tâche de régression de graphes**, nous voudrions prédire la solubilité moléculaire.

-Figure 10: Tâche de régression graphique - Chimie quantique +Figure 10 : Tâche de régression de graphes - Chimie quantique

-Figure 11: Performance de divers GCN sur la tâche de régression +Figure 11 : Performance de divers GCNs sur la tâche de régression
-Nous remarquons que dans la plupart des cas, les GCN anisotropes ont de meilleures performances que les GCN isotropes car nous utilisons des propriétés directionnelles. +Nous remarquons que dans la plupart des cas, les GCNs anisotropes ont de meilleures performances que les GCNs isotropes car nous utilisons des propriétés directionnelles. -Pour une **tâche de classification graphique**, un problème de vision par ordinateur a été choisi où nous avons des super-nœuds d'images et nous voulons classifier l'image. +Pour une **tâche de classification de graphes**, un problème de vision par ordinateur a été choisi où nous avons des super-nœuds d'images et nous voulons classifier l'image.

-Figure 12: Tâche de classification des graphes +Figure 12 : Tâche de classification de graphes

-Figure 13: Performance de divers GCN sur la tâche de classification des graphiques +Figure 13 : Performance de divers GCNs sur la tâche de classification de graphes
-Pour une tâche de **classification des arêtes**, nous avons considéré le problème d'optimisation combinatoire du problème du voyageur de commerce (abrégé en TSP en anglais pour Travelling Salesman Problem). Nous voulons savoir si une arête particuliere appartient à la solution optimale. S'il fait partie de la solution, il appartient à la classe 1, sinon à la classe 0. Ici, nous avons besoin de caractéristiques explicites des arêtes et le seul modèle qui fait un bon travail à cet égard est GatedGCN. +Pour une tâche de **classification des arêtes**, nous avons considéré le problème d'optimisation combinatoire du problème du voyageur de commerce (TSP en anglais pour *Travelling Salesman Problem*). Nous voulons savoir si une arête particuliere appartient à la solution optimale. S'il fait partie de la solution, il appartient à la classe 1, sinon à la classe 0. Ici, nous avons besoin de caractéristiques explicites des arêtes et le seul modèle qui fait un bon travail à cet égard est GatedGCN.

-Figure 14: Tâche de classification des arêtes. +Figure 14 : Tâche de classification des arêtes

-Figure 15: Performance de divers GCN sur la tâche de classification des arêtes +Figure 15 : Performance de divers GCNs sur la tâche de classification des arêtes
-Nous pouvons également utiliser les GCN pour des tâches auto-supervisées, ils ne se limitent pas à des modèles d'apprentissage supervisés. Selon le Yann, presque toutes les tâches d'apprentissage auto-supervisé exploitent une sorte de structure graphique. Lorsque nous effectuons une tâche d'apprentissage auto-supervisé dans un texte, nous prenons une séquence de mots et nous apprenons à prédire les mots manquants ou les nouvelles phrases. Il existe ici une structure graphique, qui correspond au nombre de fois qu'un mot apparaît à une certaine distance d'un autre mot. Le texte serait un graphique linéaire, et les voisins choisis seraient utilisés pour entraîner un transformer. Dans le cas de l'entraînement contrastif, où nous avons deux échantillons qui sont similaires et deux qui sont dissemblables, il s'agit essentiellement d'un graphique de similarité où deux échantillons sont liés lorsqu'ils sont similaires et s'ils ne le sont pas, ils sont considérés comme dissemblables. +Les GCNs ne se limitent pas à des modèles d'apprentissage supervisés et peuvent être utilisés pour des tâches autosupervisées. Selon Yann, presque toutes les tâches d'apprentissage autosupervisé exploitent une sorte de structure graphique. Lorsque nous effectuons une tâche d'apprentissage autosupervisé dans un texte, nous prenons une séquence de mots et nous apprenons à prédire les mots manquants ou les nouvelles phrases. Il existe ici une structure graphique, qui correspond au nombre de fois qu'un mot apparaît à une certaine distance d'un autre mot. Le texte serait un graphe linéaire et les voisins choisis seraient utilisés pour entraîner un transformer. Dans le cas de l'entraînement contrastif, où nous avons deux échantillons qui sont similaires et deux qui sont dissemblables, il s'agit essentiellement d'un graphe de similarité où deux échantillons sont liés lorsqu'ils sont similaires et s'ils ne le sont pas, ils sont considérés comme dissemblables. ## Conclusion -Les GCN généralisent les CNN aux données sur les graphes. L'opérateur de convolution a dû être repensé sur les graphes. Cette opération a donné naissance aux GCN spatiaux pour la correspondance des modèles et aux GCN spectraux pour la convolution spectrale. -Il existe une complexité linéaire pour les graphes épars et la mise en œuvre des GPU, bien que cette dernière ne soit pas encore optimisée pour la multiplication des matrices éparses. Les applications sont nombreuses, comme le montre le tableau ci-dessous. +Les GCNs généralisent les CNNs pour les donénes de type graphes. L'opérateur de convolution a dû être repensé. Cette opération a donné naissance aux GCNs spatiaux pour l'appariement de patrons et aux GCNs spectraux pour la convolution spectrale. +Il existe une complexité linéaire pour les graphes épars et l'implémentation GPU, bien que cette dernière ne soit pas encore optimisée pour la multiplication des matrices éparses. Les applications sont nombreuses, comme le montre le tableau ci-dessous.

-Figure 16: Applications +Figure 16 : Applications
diff --git a/docs/fr/week13/13-3.md b/docs/fr/week13/13-3.md index a38b5e3b7..35b272eaa 100644 --- a/docs/fr/week13/13-3.md +++ b/docs/fr/week13/13-3.md @@ -1,7 +1,7 @@ --- lang: fr lang-ref: ch.13-3 -title: Réseau convolutif sur graphe III +title: Réseau convolutif pour graphe III lecturer: Alfredo Canziani authors: Go Inoue, Muhammad Osama Khan, Muhammad Shujaat Mirza, Muhammad Muneeb Afzal date: 28 Apr 2020 @@ -17,9 +17,9 @@ Graph Convolutional Network (GCN) is one type of architecture that utilizes the Before going into details, let's have a quick recap on self-attention, as GCN and self-attention are conceptually relevant. --> -## [Introduction au réseau convolutif sur graphe](https://www.youtube.com/watch?v=2aKXWqkbpWg&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=25&t=47s) +## [Introduction au réseau convolutif pour graphe](https://www.youtube.com/watch?v=2aKXWqkbpWg&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=25&t=47s) -Le réseau convolutif sur graphe (GCN pour Graph Convolutional Network) est un type d'architecture qui utilise la structure des données. +Le réseau convolutif pour graphe (GCN pour *Graph Convolutional Network*) est un type d'architecture qui utilise la structure des données. Avant d'entrer dans les détails, faisons un rapide rappel sur l'auto-attention, car le GCN et l'auto-attention sont conceptuellement pertinents. -## [Théorie et code du réseau à rupteur convolutif à résidu sur graphe](https://www.youtube.com/watch?v=2aKXWqkbpWg&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=25&t=992s) +## [Théorie et code du GCN résiduel à porte](https://www.youtube.com/watch?v=2aKXWqkbpWg&list=PLLHTzKZzVU9eaEyErdV26ikyolxOsz6mq&index=25&t=992s) -Le réseau à rupteur convolutif à résidu sur graphe est un type de GCN qui peut être représenté comme le montre la figure 2 : +Le GCN résiduel à porte (RG CGN pour *Residual Gated GCN*) est un type de GCN qui peut être représenté comme le montre la figure 2 :

-Figure 2 : Residual Gated Graph Convolutional Network
+Figure 2 : GCN résiduel à porte Comme pour le GCN standard, le sommet $v$ est constitué de deux vecteurs : l'entrée $\boldsymbol{x}$ et sa représentation cachée $\boldsymbol{h}$. Toutefois, dans ce cas, les arêtes ont également une représentation de caractéristique, où $\boldsymbol{e_{j}^{x}}$ représente la représentation de l'arête d'entrée et $\boldsymbol{e_{j}^{h}}$ représente la représentation de l'arête cachée. @@ -216,9 +216,9 @@ $$ \tag{Eq. 5} $$ -où $\boldsymbol{x}$ est la représentation de l'entrée, $\boldsymbol{Ax}$ représente une rotation appliquée à l'entrée $\boldsymbol{x}$ et $\sum_{v_j→v}{\eta(\boldsymbol{e_{j}})\odot \boldsymbol{Bx_{j}}}$ indique la somme des multiplications par éléments des éléments entrants ayant subi une rotation $\boldsymbol{Bx_{j}}$ et d'une porte $\eta(\boldsymbol{e_{j}})$. Contrairement au GCN standard ci-dessus où nous faisons la moyenne des représentations entrantes, le terme de porte est essentiel à la mise en œuvre du GCN à portes résiduelles car il nous permet de moduler les représentations entrantes en fonction des représentations de bordure. +où $\boldsymbol{x}$ est la représentation de l'entrée, $\boldsymbol{Ax}$ représente une rotation appliquée à l'entrée $\boldsymbol{x}$ et $\sum_{v_j→v}{\eta(\boldsymbol{e_{j}})\odot \boldsymbol{Bx_{j}}}$ indique la somme des multiplications par éléments des éléments entrants ayant subi une rotation $\boldsymbol{Bx_{j}}$ et d'une porte $\eta(\boldsymbol{e_{j}})$. Contrairement au GCN standard ci-dessus où nous faisons la moyenne des représentations entrantes, le terme de porte est essentiel à la mise en œuvre du RG CGN car il nous permet de moduler les représentations des entrées en fonction des représentations des arêtes. -Notez que la sommation se fait uniquement sur les sommets ${v_j}$ qui ont des arêtes entrantes au sommet ${v}$. Le terme résiduel (dans Residual Gated GCN) vient du fait que pour calculer la représentation cachée $\boldsymbol{h}$, on ajoute la représentation d'entrée $\boldsymbol{x}$. Le terme de porte $\eta(\boldsymbol{e_{j}})$ est calculé comme indiqué ci-dessous : +Notez que la sommation se fait uniquement sur les sommets ${v_j}$ qui ont des arêtes entrantes au sommet ${v}$. Le terme résiduel (dans *Residual Gated GCN*) vient du fait que pour calculer la représentation cachée $\boldsymbol{h}$, on ajoute la représentation d'entrée $\boldsymbol{x}$. Le terme de porte $\eta(\boldsymbol{e_{j}})$ est calculé comme indiqué ci-dessous : $$ \eta(\boldsymbol{e_{j}})=\sigma(\boldsymbol{e_{j}})\bigg(\sum_{v_k→v}\sigma(\boldsymbol{e_{k}})\bigg)^{-1} @@ -239,7 +239,7 @@ $$ La représentation des arêtes cachées $\boldsymbol{e_{j}^{h}}$ est obtenue par la sommation de la représentation initiale des arêtes $\boldsymbol{e_{j}^{x}}$ et $\texttt{ReLU}(\cdot)$ appliqué à $\boldsymbol{e_{j}}$ où $\boldsymbol{e_{j}}$ est à son tour donné par la somme d'une rotation appliquée à $\boldsymbol{e_{j}^{x}}$, une rotation appliquée à la représentation en entrée $\boldsymbol{x_{j}}$ du sommet $v_{j}$ et une rotation appliquée à la représentation en entrée $\boldsymbol{x}$ du sommet $v$. -*Note : Afin de calculer les représentations cachées en aval (c’est-à-dire $2^\text{nd}$ couche de représentations cachées), nous pouvons simplement remplacer les représentations des caractéristiques d'entrée par les représentations des caractéristiques de la couche 1^\text{st}$ dans les équations ci-dessus.* +Note : afin de calculer les représentations cachées en aval (c’est-à-dire $2^\text{nd}$ couche de représentations cachées), nous pouvons simplement remplacer les représentations des caractéristiques d'entrée par les représentations des caractéristiques de la couche 1^\text{st}$ dans les équations ci-dessus. -## Conférence partie A +## Cours magistral partie A -Dans cette section, nous abordons l'architecture et la convolution des réseaux neuronaux convolutifs traditionnels. Puis nous nous étendons au domaine des graphes. Nous comprenons les caractéristiques des graphes et définissons la convolution du graphe. Enfin, nous introduisons les réseaux convolutifs spectraux sur graphe et discutons de la manière d'effectuer la convolution spectrale. +Dans cette section, nous abordons l'architecture et la convolution des ConvNets traditionnels. Puis nous nous étendons au domaine des graphes. Nous comprenons les caractéristiques des graphes et définissons la convolution pour un graphe. Enfin, nous introduisons les réseaux convolutifs spectraux pour graphe et discutons de la manière d'effectuer la convolution spectrale. -## Conférence partie B +## Cours magistral partie B -Cette section couvre le spectre complet des réseaux convolutifs sur graphe (GCN), en commençant par la mise en œuvre de la convolution spectrale par les réseaux spectraux. Elle donne ensuite un aperçu de l'applicabilité de l'autre définition convolutive de la correspondance entre les modèles et les graphes, qui conduit aux réseaux spatiaux. Diverses architectures utilisant les deux approches sont détaillées avec leurs avantages et inconvénients, expériences, références et applications correspondants. +Cette section couvre le spectre complet des réseaux convolutifs pour graphe (GCNs pour *Graph Convolutional Networks*) en commençant par la mise en œuvre de la convolution spectrale par les réseaux spectraux. Elle donne ensuite un aperçu de l'applicabilité de l'autre définition convolutive de l'appariement de patrons (*template matching*) aux graphes, qui conduit à aborder les réseaux spatiaux. Diverses architectures utilisant les deux approches sont détaillées avec leurs avantages et inconvénients, des expériences, les références et les applications correspondants. -## Pratique -Dans cette section, nous présentons le réseau convolutif sur graphe (GCN) qui est un type d'architecture utilisant la structure des données. En fait, le concept de GCN est étroitement lié à l'auto-attention. Après avoir compris la notation générale, la représentation et les équations des GCN, nous nous penchons sur la théorie et le code d'un type spécifique de GCN connu sous le nom de réseau à rupteur convolutif à résidu sur graphe. +## Travaux dirigés +Dans cette section, nous présentons le réseau convolutif pour graphe (GCN) qui est un type d'architecture utilisant la structure des données. +En fait, le concept de GCN est étroitement lié à l'auto-attention. Après avoir compris la notation générale, la représentation et les équations des GCNs, nous nous penchons sur la théorie et le code d'un type spécifique de GCN connu sous le nom de GCN résiduel à porte. diff --git a/docs/fr/week14/14-1.md b/docs/fr/week14/14-1.md index 5d45987d9..6660f0e58 100644 --- a/docs/fr/week14/14-1.md +++ b/docs/fr/week14/14-1.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.14-1 lecturer: Yann Le Cun -title: Apprentissage profond pour une prédiction structurée +title: Apprentissage profond pour une prédiction utilisant la structure authors: Junrong Zha, Muge Chen, Rishabh Yadav, Zhuocheng Xu date: 4 May 2020 translation-date: 14 Aug 2020 @@ -17,10 +17,10 @@ It is the problem of predicting variable y for a given input x which is mutually For eg: In case of speech/handwriting recognition or natural language translation, the output needs to be grammatically correct and it is not possible to limit the number of output possibilities. The task of the model is to capture the sequential, spatial, or combinatorial structure in the problem domain. --> -## [Prévision structurée](https://www.youtube.com/watch?v=gYayCG6YyO8&t=25s) +## [Prédiction utilisant la structure](https://www.youtube.com/watch?v=gYayCG6YyO8&t=25s) -Nous sommes dans le cas de la prédiction de la variable y pour une entrée x donnée qui est mutuellement dépendante et contrainte plutôt que des valeurs scalaires discrètes ou réelles. Alors la variable de sortie n'appartient pas à une seule catégorie mais peut avoir des valeurs possibles exponentielles ou infinies. -Par exemple : en cas de reconnaissance de la parole/écriture ou de traduction en langage naturel, la sortie doit être grammaticalement correcte et il n'est pas possible de limiter le nombre de possibilités de sortie. La tâche du modèle est de capturer la structure séquentielle, spatiale ou combinatoire dans le domaine du problème. +Nous sommes dans le cas de la prédiction de la variable $y$ pour une entrée $x$ donnée qui est mutuellement dépendante et contrainte plutôt que des valeurs scalaires discrètes ou réelles. Alors la variable de sortie n'appartient pas à une seule catégorie mais peut avoir des valeurs possibles exponentielles ou infinies. +Par exemple, dans le cas de la reconnaissance de la parole/écriture ou de traduction en langage naturel, la sortie doit être grammaticalement correcte et il n'est pas possible de limiter le nombre de possibilités de sortie. La tâche du modèle est de capturer la structure séquentielle, spatiale ou combinatoire dans le domaine du problème. @@ -41,20 +41,20 @@ This can be visualized as a matrix by arrranging the feature vectors from TDNN h To train this latent variable model we need to make the energy for the correct answers as small as possible and larger for every incorrect answer. To do this we use an objective function that takes in templates for wrong words and pushes them away from the current sequence of features and backpropagates the gradients. --> -### Premiers travaux sur la prédiction structurée +### Premiers travaux sur la prédiction utilisant la structure -Ce vecteur est transmis à un TDNN (Time Delay Neural Network) qui donne un vecteur de caractéristiques qui, dans le cas de systèmes de modèles, peut être comparé au softmax qui représente une catégorie. Un problème qui se pose dans le cas de la reconnaissance de la parole prononcé est que différentes personnes peuvent prononcer le même mot de différentes manières et à des vitesses différentes. Pour résoudre ce problème, on utilise la déformation dynamique du temps. +Ce vecteur est transmis à un réseau de neurones à retard temporel (TDNN pour *Time Delay Neural Network*) qui donne un vecteur de caractéristiques qui, dans le cas de systèmes de modèles, peut être comparé au softmax qui représente une catégorie. Un problème qui se pose dans le cas de la reconnaissance de la parole prononcé est que différentes personnes peuvent prononcer le même mot de différentes manières et à des vitesses différentes. Pour résoudre ce problème, on utilise la déformation dynamique du temps (DTW pour *Dynamic Time Warping*). -L'idée est de fournir au système un ensemble de modèles pré-enregistrés qui correspondent à des vecteurs de séquences ou de caractéristiques qui ont été enregistrés par quelqu'un. Le réseau neuronal est entraîné en même temps que le modèle afin que le système apprenne à reconnaître le mot pour différentes prononciations. La variable latente nous permet de modifier le vecteur de caractéristique de manière à ce qu'il corresponde à la longueur des modèles. +L'idée est de fournir au système un ensemble de patrons pré-enregistrés qui correspondent à des vecteurs de séquences ou de caractéristiques qui ont été enregistrés par quelqu'un. Le réseau neuronal est entraîné en même temps que le patron afin que le système apprenne à reconnaître le mot pour différentes prononciations. La variable latente nous permet de modifier le vecteur de caractéristique de manière à ce qu'il corresponde à la longueur des modèles.

-Figure 1. + Figure 1 : Schéma du modèle
Cela peut être visualisé sous forme de matrice en organisant les vecteurs de caractéristiques du TDNN horizontalement et les modèles de mots verticalement. Chaque entrée dans la matrice correspond à la distance entre les vecteurs de caractéristiques. Cela peut être visualisé comme un problème de graphe où le but est de partir du coin inférieur gauche et d'atteindre le coin supérieur droit en parcourant le chemin qui minimise la distance. -Pour entraîner ce modèle de variable latente, nous devons rendre l'énergie pour les bonnes réponses aussi petite que possible et plus grande pour chaque mauvaise réponse. Pour ce faire, nous utilisons une fonction objectif qui prend des modèles pour les mots incorrects, les repousse loin de la séquence actuelle des caractéristiques et rétropropage les gradients. +Pour entraîner ce modèle de variable latente, nous devons rendre l'énergie pour les bonnes réponses aussi petite que possible et plus grande pour chaque mauvaise réponse. Pour ce faire, nous utilisons une fonction objectif qui prend des patrons pour les mots incorrects, les repousse loin de la séquence actuelle des caractéristiques et rétropropage les gradients. @@ -69,13 +69,13 @@ Figure 2. --> -## Graphes de facteurs à base d'énergie +## Graphes factoriels à base d'énergie -L'idée derrière les graphes de facteurs à base d'énergie est de construire un EBM dans lequel l'énergie est la somme de termes énergétiques partiels ou lorsque la probabilité est un produit de facteurs. L'avantage de ces modèles est que des algorithmes d'inférence efficaces peuvent être utilisés. +L'idée derrière les graphes factoriels à base d'énergie est de construire un EBM dans lequel l'énergie est la somme de termes énergétiques partiels ou lorsque la probabilité est un produit de facteurs. L'avantage de ces modèles est que des algorithmes d'inférence efficaces peuvent être utilisés.

-Figure 2. +Figure 2 : Graphes factoriels à base d'énergie
@@ -98,18 +98,20 @@ In this case, the energy is a sum of three terms represented by blue squares whi ### Labellisation des séquences -Le modèle prend un signal vocal d'entrée X et émet les labels Y de telle sorte que les labels de sortie minimisent le terme énergétique total. +Le modèle prend un signal vocal d'entrée $X$ et sort les labels $Y$ de telle sorte que les labels de sortie minimisent le terme d'énergie total. +

-Figure 3. +Figure 3 : Minimisation de l'énergie
+

-Figure 4. +Figure 4 : Minimisation de l'énergie sous la forme d'un graphe
-Dans ce cas, l'énergie est une somme de trois termes représentés par des carrés bleus qui sont des réseaux de neurones produisant des vecteurs caractéristiques pour les variables d'entrée. Dans le cas de la reconnaissance vocale, X peut être considéré comme un signal vocal et les carrés implémentent les contraintes grammaticales et Y représente les labels de sortie générées. +Dans ce cas, l'énergie est une somme de trois termes représentés par des carrés bleus qui sont des réseaux de neurones produisant des vecteurs caractéristiques pour les variables d'entrée. Dans le cas de la reconnaissance vocale, $X$ peut être considéré comme un signal vocal et les carrés implémentent les contraintes grammaticales et $Y$ représente les labels de sortie générées. -## [Inférence efficace pour les graphes de facteurs à base d'énergie](https://www.youtube.com/watch?v=gYayCG6YyO8&t=1086s) +## [Inférence efficace pour les graphes factoriels à base d'énergie](https://www.youtube.com/watch?v=gYayCG6YyO8&t=1086s) -Un tutoriel sur l'apprentissage basé sur l'énergie (Yann Le Cun, Sumit Chopra, Raia Hadsell, Marc'Aurelio Ranzato, et Fu Jie Huang 2006). +Un tutoriel sur l'apprentissage basé sur l'énergie est disponible [ici](yann.lecun.com/exdb/publis/pdf/lecun-06.pdf) (Le Cun et al. (2006)). -L'apprentissage et l'inférence avec les modèles à base d'énergie impliquent une minimisation de l'énergie sur l'ensemble des réponses $\mathcal{Y}$ et des variables latentes $\mathcal{Z}$. Lorsque la cardinalité de $\mathcal{Y}\times \mathcal{Z}$ est importante, cette minimisation peut devenir insoluble. Une approche du problème consiste à exploiter la structure de la fonction énergie afin d'effectuer la minimisation de manière efficace. Un cas où la structure peut être exploitée se produit lorsque l'énergie peut être exprimée comme une somme de fonctions individuelles (appelées facteurs) qui dépendent chacune de différents sous-ensembles des variables de Y et Z. Ces dépendances sont mieux exprimées sous la forme d'un graphe de facteurs. Les graphes factoriels sont une forme générale de modèles graphiques ou de réseaux de croyances. +L'apprentissage et l'inférence avec les modèles à base d'énergie impliquent une minimisation de l'énergie sur l'ensemble des réponses $\mathcal{Y}$ et des variables latentes $\mathcal{Z}$. Lorsque la cardinalité de $\mathcal{Y}\times \mathcal{Z}$ est importante, cette minimisation peut devenir insoluble. Une approche du problème consiste à exploiter la structure de la fonction énergie afin d'effectuer la minimisation de manière efficace. Un cas où la structure peut être exploitée se produit lorsque l'énergie peut être exprimée comme une somme de fonctions individuelles (appelées facteurs) qui dépendent chacune de différents sous-ensembles des variables de $\mathcal{Y}$ et $\mathcal{Z}$. Ces dépendances sont mieux exprimées sous la forme d'un graphe factoriel. Les graphes factoriels sont une forme générale de modèles graphiques ou de réseaux de croyances.

-Figure 5. + Figure 5 : Graphes factoriels à base d'énergie
-Un exemple simple de graphe de facteur est présenté à la figure 19 (en haut). La fonction énergie est la somme de quatre facteurs : +Un exemple simple de graphe de facteur est présenté à la figure 5 (en haut). La fonction énergie est la somme de quatre facteurs : $$E(Y, Z, X) = E_a(X, Z_1) + E_b(X, Z_1, Z_2) + E_c(Z_2, Y_1) + E_d(Y_1, Y_2)$$ @@ -168,19 +170,18 @@ où $Y = [Y_1, Y_2]$ sont les variables de sortie et $Z = [Z_1, Z_2]$ sont les v $$(\bar{Y}, \bar{Z})=\operatorname{argmin}_{y \in \mathcal{Y}, z \in \mathcal{Z}}\left(E_{a}\left(X, z_{1}\right)+E_{b}\left(X, z_{1}, z_{2}\right)+E_{c}\left(z_{2}, y_{1}\right)+E_{d}\left(y_{1}, y_{2}\right)\right)$$ -Supposons que $Z_1$, $Z_2$ et $Y_1$ sont des variables binaires discrètes et que $Y_2$ est une variable ternaire. La cardinalité du domaine de $X$ est sans importance puisque X est toujours observé. Le nombre de configurations possibles de $Z$ et $Y$ étant donné X est de 2 \times 2 \times 2 \times 3 = 24$. Un algorithme de minimisation naïf par recherche exhaustive évaluerait la fonction énergie entière 24 fois (96 évaluations à facteur unique). +Supposons que $Z_1$, $Z_2$ et $Y_1$ sont des variables binaires discrètes et que $Y_2$ est une variable ternaire. La cardinalité du domaine de $X$ est sans importance puisque $X$ est toujours observé. Le nombre de configurations possibles de $Z$ et $Y$ étant donné $X$ est de $2 \times 2 \times 2 \times 3 = 24$. Un algorithme de minimisation naïf par recherche exhaustive évaluerait la fonction énergie entière 24 fois (96 évaluations à facteur unique). -Cependant, nous remarquons que pour un $X$ donné, $E_a$ n'a que deux configurations d'entrée possibles : $Z_1 = 0$ et $Z_1 = 1$. De même, $E_b$ et $E_c$ n'ont que 4 configurations d'entrée possibles, et $E_d$ en a 6, -il n'est pas nécessaire d'avoir plus de $2 + 4 + 4 + 6 = 16$ d'évaluations à facteur unique. +Cependant, nous remarquons que pour un $X$ donné, $E_a$ n'a que deux configurations d'entrée possibles : $Z_1 = 0$ et $Z_1 = 1$. De même, $E_b$ et $E_c$ n'ont que 4 configurations d'entrée possibles, et $E_d$ en a 6, il n'est pas nécessaire d'avoir plus de $2 + 4 + 4 + 6 = 16$ d'évaluations à facteur unique. -Nous pouvons donc pré-calculer les 16 valeurs de facteurs et les placer sur les arcs d'un treillis comme le montre la figure 19 (en bas). +Nous pouvons donc précalculer les 16 valeurs de facteurs et les placer sur les arcs d'un *trellis* comme le montre la figure 5 (en bas). Les nœuds de chaque colonne représentent les valeurs possibles d'une seule variable. Chaque arc est pondéré par l'énergie de sortie du facteur pour les valeurs correspondantes de ses variables d'entrée. Avec cette représentation, un seul chemin du nœud de départ au nœud d'arrivée représente une configuration possible de toutes les variables. La somme des poids le long d'un chemin est égale à l'énergie totale pour la configuration correspondante. Par conséquent, le problème d'inférence peut être réduit à la recherche du **plus court chemin** dans ce graphe. Ceci peut être réalisé en utilisant une méthode de programmation dynamique telle que l'algorithme de Viterbi, ou l'algorithme A*. Le coût est proportionnel au nombre d'arêtes (16), qui est exponentiellement plus petit que le nombre de chemins en général. Pour calculer $E(Y, X) = \min_{z\in Z} E(Y, z, X)$, nous suivons la même procédure, mais nous limitons le graphe au sous-ensemble des arcs qui sont compatibles avec la valeur prescrite de $Y$. -La procédure ci-dessus est parfois appelée l'algorithme min-sum, et c'est la version du domaine logarithmique du produit max traditionnel pour les modèles graphiques. La procédure peut facilement être généralisée aux graphes factoriels où les facteurs prennent plus de deux variables comme entrées, et aux graphes factoriels qui ont une structure arborescente au lieu d'une structure en chaîne. +La procédure ci-dessus est parfois appelée l'algorithme min-sum et c'est la version du domaine logarithmique du produit max traditionnel pour les modèles graphiques. La procédure peut facilement être généralisée aux graphes factoriels où les facteurs prennent plus de deux variables comme entrées et aux graphes factoriels qui ont une structure arborescente au lieu d'une structure en chaîne. Toutefois, elle ne s'applique qu'aux graphes de facteurs qui sont des arbres bipartites (sans boucles). Lorsque des boucles sont présentes dans le graphe, l'algorithme de la somme minimale peut donner une solution approximative lorsqu'il est répété, ou peut ne pas converger du tout. Dans ce cas, un algorithme de descente tel que le recuit simulé pourrait être utilisé. @@ -204,16 +205,14 @@ Here $\mathcal{F}$ denotes the set of factors (the set of pairs of individual la And then we can think about like what type of loss function. Here comes several different models. --> -## Graphes de facteur simples à base d'énergie avec facteurs "peu profonds" +## Graphes factoriels simples à base d'énergie avec facteurs peu profonds

-Figure 6. + Figure 6 : Graphe factoriel pour des modèles à structure linéaire
-Le graphe de facteur présenté à la figure 20 est un graphe de facteur logarithmique pour les modèles linéaires structurés ("graphe de facteur simples à base d'énergie" dont nous parlons) - -Chaque facteur est une fonction $X$ et d'une paire de labels individuels $(Y_m, Y_n)$. En général, chaque facteur peut dépendre de plus de deux labels individuels, mais nous limiterons la discussion aux facteurs par paires pour simplifier la notation : +Chaque facteur dans la figure 6 est une fonction $X$ et d'une paire de labels individuels $(Y_m, Y_n)$. En général, chaque facteur peut dépendre de plus de deux labels individuels, mais nous limiterons la discussion aux facteurs par paires pour simplifier la notation : $$E(W, Y, X)=\sum_{(m, n) \in \mathcal{F}} W_{m n}^{T} f_{m n}\left(X, Y_{m}, Y_{n}\right)$$ @@ -238,7 +237,7 @@ $$\mathcal{L}_{\mathrm{nll}}(W)=\frac{1}{P} \sum_{i=1}^{P} E\left(W, Y^{i}, X^{i ### Champ aléatoire conditionnel -Nous pouvons utiliser la fonction de perte de log-vraisemblance négative pour entraîner un modèle linéaire structuré. +Nous pouvons utiliser la fonction de perte de log-vraisemblance négative pour entraîner un modèle à structure linéaire. Il s'agit du champ aléatoire conditionnel. @@ -259,13 +258,13 @@ The intuition behind is that we want the energy of the correct answer to be low, This is the idea behind Max Margin Markov Nets and Latent SVM. --> -### Réseaux de Markov à marge maximale et SVM latent +### Réseaux de Markov à marge maximale et les SVMs latentes -Nous pouvons également utiliser la fonction de perte Hinge pour l'optimisation. +Nous pouvons également utiliser la fonction de perte *Hinge* pour l'optimisation. L'intuition est que nous voulons que l'énergie de la bonne réponse soit faible, puis parmi toutes les configurations possibles de réponses incorrectes, nous allons chercher celle qui a l'énergie la plus faible parmi toutes les mauvaises ou les mauvaises réponses. Et nous allons ensuite augmenter l'énergie de celle-ci. Nous n'avons pas besoin d'augmenter l'énergie pour les autres mauvaises réponses parce qu'elles sont de toute façon plus grandes. -C'est l'idée qui sous-tend les réseaux de Markov à marge maximale et le SVM latent. +C'est l'idée qui sous-tend les réseaux de Markov à marge maximale et les SVM latentes. -### Modèle de Perceptron structuré +### Modèle avec une strcuture perceptron -Nous pouvons entraîner le modèle linéaire structuré en utilisant la perte de perceptron. +Nous pouvons entraîner un modèle linéaire en utilisant la perte de perceptron. -Collins [Collins, 2000, Collins, 2002] a préconisé son utilisation pour les modèles linéaires structurés dans le contexte du NLP : +Collins (2000 et 2002) a préconisé son utilisation pour les modèles linéaires structurés dans le contexte du traitement du langage naturel : $$ \mathcal{L}_{\text {perceptron }}(W)=\frac{1}{P} \sum_{i=1}^{P} E\left(W, Y^{i}, X^{i}\right)-E\left(W, Y^{* i}, X^{i}\right) @@ -302,11 +301,10 @@ Minimum Empirical Error Loss (Ljolje, and Rabiner 1990): By training at sequence level, they do not tell the system this sound or that location. They give the system input sentence and transcription of it in term of words, and ask the system to figure it out by doing time warping. They did not use nerual networks, and have other ways in turning speech signals into sound categories. --> -#### Premières pistes sur l'entraînement discriminant pour la reconnaissance de la parole et de l'écriture. - -Minimum Empirical Error Loss (Ljolje, et Rabiner 1990) : +#### Premières pistes sur un entraînement discriminant pour la reconnaissance de la parole et de l'écriture -En s'entraînant au niveau de la séquence, ils n'indiquent pas au système tel ou tel son ou tel endroit. Ils donnent au système la phrase d'entrée et sa transcription en termes de mots, et demandent au système de la comprendre en faisant une distorsion temporelle. +*Minimum Empirical Error Loss* (Ljolje et Rabiner 1990) : +En entraînant au niveau de la séquence, ils n'indiquent pas au système tel ou tel son ou tel endroit. Ils donnent au système la phrase d'entrée et sa transcription en termes de mots, et demandent au système de la comprendre en faisant une distorsion temporelle. Ils n'ont pas utilisé de réseaux de neurones, et disposent d'autres moyens pour transformer les signaux vocaux en catégories de sons. -## [Réseau transformer de graphe](https://www.youtube.com/watch?v=gYayCG6YyO8&t=2610s) +## [Graph Transformer Network (GTN)](https://www.youtube.com/watch?v=gYayCG6YyO8&t=2610s) Ici, le problème est que nous avons une séquence de chiffres à l'entrée et que nous ne savons pas comment faire la segmentation. Nous pouvons néanmoins construire un graphe dans lequel chaque chemin est un moyen de décomposer la séquence de caractères, et nous allons trouver le chemin avec la plus faible énergie. En gros cela revient à trouver le chemin le plus court. Voici un exemple concret de la façon dont cela fonctionne. -Nous avons en entrée l'image du nombre 34. Passez-la dans le segmenteur et obtenez plusieurs segmentations alternatives. Ces segmentations sont des moyens de regrouper ces blocs de choses. Chaque chemin dans le graphe de segmentation correspond à une façon particulière de regrouper les taches d'encre. +Nous avons en entrée l'image du nombre 34. On la passe dans le segmenteur et on obtient plusieurs segmentations alternatives. Ces segmentations sont des moyens de regrouper ces blocs de choses. Chaque chemin dans le graphe de segmentation correspond à une façon particulière de regrouper les taches d'encre.

-Figure 7. + Figure 7 : Image d'un 34
-Nous passons chaque segment ? trucs ? par le même ConvNet de reconnaissance des caractères, et obtenons une liste de 10 scores (deux ici mais essentiellement 10, représentant 10 catégories). Par exemple, 1 [0,1] signifie que l'énergie est de 0,1 pour la catégorie 1. J'obtiens donc un graphe ici, et vous pouvez le considérer comme une forme étrange de tenseur. Il s'agit en fait d'un tenseur peu dense. C'est un tenseur qui dit que pour chaque configuration possible de cette variable, dites-moi le coût de la variable. C'est plus comme une distribution sur les tenseurs, ou une distribution logarithmique parce que nous parlons d'énergies. +Nous passons chaque segment par le même ConvNet de reconnaissance des caractères et obtenons une liste de 10 scores (deux ici mais essentiellement 10, représentant 10 catégories). Par exemple, *1 [0,1]* signifie que l'énergie est de 0,1 pour la catégorie 1. J'obtiens donc un graphe ici, et vous pouvez le considérer comme une forme étrange de tenseur. Il s'agit en fait d'un tenseur peu dense. C'est un tenseur qui pour chaque configuration possible de cette variable, demande le coût de la variable. Il s'agit davantage d'une distribution sur les tenseurs, ou une distribution logarithmique car nous parlons d'énergies.

-Figure 8. + Figure 8 : Graphe d'ensemble
-Prenez ce graphe et ensuite calculez l'énergie de la bonne réponse. Je vous dis que la bonne réponse est 34. Sélectionnez dans ces chemins et trouvez ceux qui disent 34. Il y en a deux, l'une est l'énergie 3,4 + 2,4 = 5,8, et l'autre 0,1 + 0,6 = 0,7. Choisissez le chemin qui a l'énergie la plus faible. Ici, nous obtenons le chemin avec l'énergie 0,7. +Si on prend le graphe de la figure 9 et devons calculer l'énergie de la bonne réponse (34), nous devons sélectionner dans ces chemins ceux donnant la bonne réponse. Il y en a deux, l'une est l'énergie 3,4 + 2,4 = 5,8 et l'autre 0,1 + 0,6 = 0,7. Il nous reste alors plus qu'à prendre le chemin qui a l'énergie la plus faible. Ici, nous obtenons le chemin avec l'énergie 0,7.

-Figure 9. + Figure 9 : Graphe avec les valeurs d'énergie
-Trouver le chemin est donc comme minimiser sur la variable latente où la variable latente est le chemin que vous choisissez. Conceptuellement, il s'agit d'un modèle énergétique avec une variable latente comme chemin. +Trouver le chemin est donc comme minimiser sur une variable latente où la variable latente est le chemin que vous choisissez. Conceptuellement, il s'agit d'un modèle d'énergie avec une variable latente comme chemin. -Nous avons maintenant l'énergie du chemin correct, 0,7. Ce que nous devons faire maintenant, c'est rétropropager le gradient à travers toute cette structure, afin de pouvoir modifier le poids dans le ConvNet de telle sorte que l'énergie finale diminue. Cela semble intimidant, mais c'est tout à fait possible. Comme tout ce système est construit à partir d'éléments que nous connaissons déjà, le réseau neuronal est régulier et le sélecteur de chemin et le transformateur de Viterbi sont essentiellement des swtiches qui choisissent un bord particulier ou non. +Nous avons donc l'énergie du chemin correct, 0,7. Ce que nous devons faire maintenant, c'est rétropropager le gradient à travers toute cette structure, afin de pouvoir modifier le poids dans le ConvNet de telle sorte que l'énergie finale diminue. Cela semble intimidant, mais c'est tout à fait possible. Comme tout ce système est construit à partir d'éléments que nous connaissons déjà, le réseau neuronal est ordinaire et le sélecteur de chemin et le transformateur de Viterbi sont essentiellement des interrupteurs qui choisissent un bord particulier ou non. -Alors comment se propager en arrière. Eh bien, le point 0,7 est la somme de 0,1 et 0,6. Donc, les points 0,1 et 0,6 auront tous deux une pente de +1, qui sont indiqués entre parenthèses. Ensuite, le Transformer de Viterbi n'a qu'à sélectionner un chemin parmi deux. Il suffit donc de copier le gradient pour l'arête correspondante dans le graphe d'entrée et de définir la pente pour les autres trajectoires qui ne sont pas sélectionnées comme étant nulles. C'est exactement ce qui se passe dans le Max-Pooling ou le Mean-Pooling. Le sélecteur de trajectoire est le même, c'est juste un système qui sélectionne la bonne réponse. Notez que 3 [0.1] (0) dans le graphe devrait être 3 [0.1] (1) à ce stade, et nous y reviendrons plus tard. Vous pouvez alors rétroprogrammer le gradient à travers le réseau de nerfs. Cela rendra l'énergie de la bonne réponse faible. +Alors comment rétropropager ? Le point 0,7 est la somme de 0,1 et 0,6. Donc, les points 0,1 et 0,6 auront tous deux une pente de +1, qui sont indiqués entre parenthèses. Ensuite, le Transformer de Viterbi n'a qu'à sélectionner un chemin parmi deux. Il suffit donc de copier le gradient pour l'arête correspondante dans le graphe d'entrée et de définir la pente pour les autres trajectoires qui ne sont pas sélectionnées comme étant nulles. C'est exactement ce qui se passe dans le *max-pooling* ou le *mean-pooling*. Le sélecteur de trajectoire est le même, c'est juste un système qui sélectionne la bonne réponse. Notez que *3 [0.1] (0)* dans le graphe devrait être à ce stade être *3 [0.1] (1)*. Vous pouvez alors rétroprogager le gradient à travers le réseau de nerfs. Cela rend l'énergie de la bonne réponse faible. -Ce qui est important ici, c'est que cette structure est dynamique, car si je vous donne une nouvelle entrée, le nombre d'instances du réseau névralgique changera avec le nombre de segmentations, et les graphes dérivés changeront également. Nous devons faire une rétropropagation à travers cette structure dynamique. C'est là que des choses comme PyTorch sont vraiment importantes. +Ce qui est important ici, c'est que cette structure est dynamique, car si on vous donne une nouvelle entrée, le nombre d'instances du réseau névralgique changera avec le nombre de segmentations et les graphes dérivés changeront également. Nous devons faire une rétropropagation à travers cette structure dynamique. C'est là que des choses comme PyTorch sont vraiment importantes. Cette phrase de rétropropagation rend l'énergie de la bonne réponse faible. Et il y aura une deuxième phrase où nous allons rendre l'énergie de la mauvaise réponse grande. Dans ce cas, nous laissons le système choisir la réponse qu'il veut. Il s'agira d'une forme simplifiée d'entraînement discriminatoire pour la prédiction des structures qui utilisent la perte de perception. -Les premières étapes de la deuxième phrase sont exactement les mêmes que celles de la première phrase. Le Transformer de Viterbi ici choisira simplement le meilleur chemin avec la plus faible énergie, nous ne nous soucions pas de savoir si ce chemin est correct ou non ici. L'énergie que vous obtenez ici sera plus petite ou égale à celle que vous obtenez dans la première phrase, puisque l'énergie obtenue ici est la plus petite de toutes les voies possibles. +Les premières étapes de la deuxième phrase sont exactement les mêmes que celles de la première phrase. Le Transformer de Viterbi ici choisira simplement le meilleur chemin avec la plus faible énergie. Nous ne nous soucions pas de savoir si ce chemin est correct ou non ici. L'énergie que vous obtenez ici sera plus petite ou égale à celle que vous obtenez dans la première phrase, puisque l'énergie obtenue ici est la plus petite de toutes les voies possibles.

-Figure 10. + Figure 10 : Raisonnement de la rétropropagation
-Mettre la phase une et deux ensemble. La fonction de perte devrait être énergie1 - énergie2. Avant, nous avons introduit la rétropropagation par la partie gauche et maintenant nous devons en fait rétropropager à travers toute la structure. Quel que soit le chemin sur le côté gauche il obtiendra +1 et quel que soit le chemin sur le côté droit il obtiendra -1. Donc 3 [0,1] est apparu dans les deux chemins, donc devrait obtenir un gradient nul. Si nous faisons cela, le système finira par minimiser la différence entre l'énergie de la bonne réponse et l'énergie de la meilleure réponse quelle qu'elle soit. La fonction de perte ici est la perte de perceptron. +En mettant la phase une et deux ensemble, la fonction de perte devrait être $énergie1 - énergie2$. Avant, nous avons introduit la rétropropagation par la partie gauche et maintenant nous devons en fait rétropropager à travers toute la structure. Quel que soit le chemin sur le côté gauche on obtiendra +1 et quel que soit le chemin sur le côté droit on obtiendra -1. Donc *3 [0,1]* est apparu dans les deux chemins, donc devrait obtenir un gradient nul. Si nous faisons cela, le système finira par minimiser la différence entre l'énergie de la bonne réponse et l'énergie de la meilleure réponse quelle qu'elle soit. La fonction de perte ici est la perte de perceptron.

-Figure 11. + Figure 11 : Raisonnement de la rétropropagation sur deux chemins
-Mise en place de la première et de la deuxième phase. La fonction de perte devrait être énergie1 - énergie2. Avant, nous avons introduit la rétropropagation par la partie gauche, et maintenant, nous devons en fait rétropropager à travers toute la structure. Quel que soit le chemin sur le côté gauche, il obtiendra +1, et quel que soit le chemin sur le côté droit, il obtiendra -1. Donc 3 [0,1] est apparu dans les deux chemins, donc devrait obtenir un gradient 0. Si nous faisons cela, le système finira par minimiser la différence entre l'énergie de la bonne réponse et l'énergie de la meilleure réponse, quelle qu'elle soit. La fonction de perte ici est la perte de perceptron. - -## Questions / Réponses +## Questions des étudiants -#### Question1 : Pourquoi l'inférence est-elle facile dans le cas des graphes de facteurs à base d'énergie ? - -L'inférence dans le cas de l’EBM avec variable latente implique l'utilisation de techniques exhaustives telles que la descente de gradient pour minimiser l'énergie. Cependant, puisque l'énergie, dans ce cas, est la somme des facteurs, des techniques telles que la programmation dynamique peuvent être utilisées à la place. +**Pourquoi l'inférence est-elle facile dans le cas des graphes factoriels à base d'énergie ?** +> L'inférence dans le cas d'un EBM avec variable latente implique l'utilisation de techniques exhaustives telles que la descente de gradient pour minimiser l'énergie. Cependant, puisque l'énergie, dans ce cas, est la somme des facteurs, des techniques telles que la programmation dynamique peuvent être utilisées à la place. -#### Question 2 : Que faire si les variables latentes des graphes de facteurs sont des variables continues ? Peut-on encore utiliser l'algorithme min-sum ? - -Nous ne le pouvons pas, car nous ne pouvons pas rechercher toutes les combinaisons possibles pour toutes les valeurs des facteurs maintenant. Cependant, dans ce cas, les énergies nous donnent aussi un avantage, car nous pouvons faire des optimisations indépendantes. Comme la combinaison de $Z_1$ et $Z_2$ n'affecte que $E_b$ dans la figure 19. Nous pouvons faire des optimisations indépendantes et une programmation dynamique pour faire l'inférence. +**Que faire si les variables latentes des graphes factoriels sont des variables continues ? Peut-on encore utiliser l'algorithme min-sum ?** +> Nous ne le pouvons pas, car nous ne pouvons pas rechercher toutes les combinaisons possibles pour toutes les valeurs des facteurs maintenant. Cependant, dans ce cas, les énergies nous donnent aussi un avantage car nous pouvons faire des optimisations indépendantes. Comme la combinaison de $Z_1$ et $Z_2$ n'affecte que $E_b$ dans la figure 5. Nous pouvons faire des optimisations indépendantes et une programmation dynamique pour faire l'inférence. -#### Question3 : Les boîtes NN font-elles référence à des ConvNets séparés ? -Elles sont partagées. Ce sont des copies multiples du même ConvNet. Il s'agit simplement d'un réseau de reconnaissance de caractères. +**Question3 : Les boîtes font-elles référence à des ConvNets séparés ?** +> Elles sont partagées. Ce sont des copies multiples du même ConvNet. Il s'agit simplement d'un réseau de reconnaissance de caractères. diff --git a/docs/fr/week14/14-2.md b/docs/fr/week14/14-2.md index 4cb8963a3..85b1d7229 100644 --- a/docs/fr/week14/14-2.md +++ b/docs/fr/week14/14-2.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.14-2 lecturer: Yann Le Cun -title: Méthodes à base d'énergie graphiques +title: Méthodes graphiques à base d'énergie authors: Yada Pruksachatkun, Ananya Harsh Jha, Joseph Morag, Dan Jefferys-White, and Brian Kelly date: 4 May 2020 translation-date: 14 Aug 2020 @@ -32,7 +32,7 @@ A: The segment is handcrafted heuristics. The model uses a handcrafted segment a

-Figure 1 : Architecture de réseau + Figure 1 : Architecture de réseau
Dans la figure ci-dessus, les chemins incorrects ont une valeur de -1. @@ -41,9 +41,8 @@ Yann commence par la perte de perceptron, qui est utilisée dans l'exemple du *G En termes de mise en œuvre, vous représenterez les arcs dans la visualisation avec un vecteur. Plutôt qu'un arc séparé pour chaque catégorie, un vecteur contient à la fois les catégories et le score de chaque catégorie. -**Q** : Comment le segmenteur est-il implémenté dans le modèle ci-dessus ? - -**R** : Le segmenteur est une heuristique artisanale. Le modèle utilise un segment artisanal bien qu'il y ait un moyen de le rendre entraînable de bout en bout. Cette approche artisanale a été remplacée par l'approche de la fenêtre coulissante pour la reconnaissance des caractères. +**Comment le segmenteur est-il implémenté dans le modèle ci-dessus ?** +> Le segmenteur est une heuristique artisanale. Le modèle utilise un segment artisanal bien qu'il y ait un moyen de le rendre entraînable de bout en bout. Cette approche artisanale a été remplacée par l'approche de la fenêtre coulissante pour la reconnaissance des caractères. @@ -88,10 +87,10 @@ Tableau 1 : Diverses équations de perte | Équation de perte | Formule | Marge | | :---- | :---- : | ---:| | Perte d'énergie | $\text{E}(\text{W}, \text{Y}^i, \text{X}^i)$ | Aucune | -| Perceptron | $\text{E}(\text{W}, \text{Y}^i, \text{X}^i)-\min\limites_{\text{Y}\in\mathcal{Y}}\text{E}(\text{W}, \text{Y}, \text{X}^i)$ | 0 | -| Hinge | $\max\big(0, m + \text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)$ | $m$ | -| Log | $\log\bigg(1+\exp\big(\text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\bigg)$ | >0 | -| LVQ2 | $\min\bigg(M, \max\big(0, \text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\bigg)$ | 0 | +| Perceptron | $\text{E}(\text{W}, \text{Y}^i, \text{X}^i)-\min\limits_{\text{Y}\in\mathcal{Y}}\text{E}(\text{W}, \text{Y}, \text{X}^i)$ | 0 | +| Hinge | $\max\big(0, m + \text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)$ | $m$ | +| Log | $\log\bigg(1+\exp\big(\text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\bigg)$ | >0 | +| LVQ2 | $\min\bigg(M, \max\big(0, \text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\bigg)$ | 0 | | MCE | $\bigg(1+\exp\Big(-\big(\text{E}(\text{W}, \text{Y}^i,\text{X}^i)-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\Big)\bigg)^{-1}$| >0 | | Square-Square | $\text{E}(\text{W}, \text{Y}^i,\text{X}^i)^2-\bigg(\max\big(0, m - \text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)\bigg)^2$ | $m$ | | Square-Exp | $\text{E}(\text{W}, \text{Y}^i,\text{X}^i)^2 + \beta\exp\big(-\text{E}(\text{W}, \overline{\text{Y}}^i,\text{X}^i)\big)$ | >0 | @@ -99,15 +98,14 @@ Tableau 1 : Diverses équations de perte | MEE |$1-\frac{\exp\big(-\beta E(W,Y^i,X^i)\big)}{\int_{y\in\mathcal{Y}}\exp\big(-\beta E(W,y,X^i)\big)}$ | >0 | -La perte de perceptron observée dans le tableau ci-dessus n'a pas de marge, et donc la perte risque de s'effondrer. +La perte de perceptron observée dans le tableau ci-dessus n'a pas de marge et donc risque de s'effondrer. * La perte de perceptron consiste à calculer la différence d’énergie entre celle de la réponse la plus offensante et celle de la bonne réponse. Intuitivement, avec une marge m, l’hinge aura une perte de 0 que lorsque l'énergie correcte est inférieure à l'énergie la plus offensante *d'au moins* m. * La perte MCE est utilisée dans la reconnaissance vocale, et ressemble à un sigmoïde. * La perte NLL vise à rendre l'énergie de la bonne réponse petite et la composante logarithmique de l'équation grande. -**Q** : Comment l’hinge peut-elle être meilleure que la perte NLL ? - -**R** : L’hinge est meilleure que la perte NLL parce que NLL essaie de pousser la différence entre la bonne réponse et les autres réponses à l'infini, alors que l'hinge veut seulement la rendre plus grande qu'une certaine valeur (la marge m). +**Comment la perte hinge peut-elle être meilleure que la perte NLL ?** +> La perte hinge est meilleure que la perte NLL parce que NLL essaie de pousser la différence entre la bonne réponse et les autres réponses à l'infini, alors que l'hinge veut seulement la rendre plus grande qu'une certaine valeur (la marge m). -## Algorithme forward dans les réseaux Transformer de graphe +## Algorithme *forward dans* les réseaux *Graph Transformer Networks* -### Composition des graphes +### Composition de graphes -La composition des graphes nous permet de combiner deux graphes. Dans cet exemple, nous pouvons voir un lexique de modèle de langage représenté par un $trie$ (un graphe) et un graphe de reconnaissance qui est produit par un réseau de neurones. +La composition de graphes nous permet de combiner deux graphes. Dans cet exemple, nous pouvons voir un lexique de modèle de langage représenté par un $trie$ (un graphe) et un graphe de reconnaissance qui est produit par un réseau de neurones.

-Figure 2 : Composition de graphe +Figure 2 : Composition de graphes
Le graphe de reconnaissance spécifie avec différentes valeurs d'énergie (associées à chaque arc) la probabilité qu'un personnage se trouve à une étape particulière. @@ -203,7 +198,7 @@ Toute l'architecture d'un lecteur de chèques du milieu des années 90 est assez

-Figure 3 : Lecteur de chèque +Figure 3 : Lecteur de chèque
Ce graphe de reconnaissance subit deux opérations de composition distinctes, la première avec l'interprétation correcte (ou la vérité de base) et la seconde avec la grammaire qui crée un graphe de toutes les interprétations possibles. @@ -262,13 +257,13 @@ $$F_{\beta} (x, y) = -\frac{1}{\beta} \; \log \; \sum_{z \, \in \, \text{paths}} Cela est marginalisant par rapport à la variable latente z, qui définit les chemins dans un graphe d'interprétation. Cette approche calcule la valeur exponentielle de cette somme logarithmique sur tous les chemins possibles vers un nœud particulier. C'est comme si l'on peignait le coût de tous les chemins possibles d'une manière douce et minimale. -L'algorithme de forward est peu coûteux à mettre en œuvre et ne coûte pas plus cher que l'algorithme de Viterbi. De plus, nous pouvons faire une rétropropagation à travers le nœud de l'algorithme direct dans le graphe. +L'algorithme *forward* est peu coûteux à mettre en œuvre et ne coûte pas plus cher que l'algorithme de Viterbi. De plus, nous pouvons faire une rétropropagation à travers le nœud de l'algorithme direct dans le graphe. Le fonctionnement de l'algorithme avancé peut être montré à l'aide de l'exemple suivant défini sur un graphe d'interprétation.

-Figure 4 : Graphe d'interprétation +Figure 4 : Graphe d'interprétation
@@ -319,12 +314,12 @@ Nous pouvons effectuer une rétropropagation à travers le graphe d'interprétat

-Figure 5 : Lecteur de chèque +Figure 5 : Lecteur de chèque
-Pour revenir à l'exemple du lecteur de chèque, nous appliquons l'algorithme de forward sur les deux compositions de graphes et obtenons la valeur énergétique au dernier nœud en utilisant la log sum exponentielle forumla. La différence entre ces valeurs énergétiques est la perte de log-vraisemblance négative. +Pour revenir à l'exemple du lecteur de chèque, nous appliquons l'algorithme *forward* sur les deux compositions de graphes et obtenons la valeur énergétique au dernier nœud en utilisant la log sum exponentielle forumla. La différence entre ces valeurs énergétiques est la perte de log-vraisemblance négative. -La valeur obtenue en appliquant l'algorithme de forward sur la composition du graphe entre la bonne réponse et le graphe de reconnaissance est la valeur exponentielle de la somme logarithmique de la bonne réponse. En revanche, la valeur exponentielle de la somme des logarithmes au dernier nœud de la composition du graphe entre le graphe de reconnaissance et la grammaire est la valeur marginale de toutes les interprétations valides possibles. +La valeur obtenue en appliquant l'algorithme *forward* sur la composition du graphe entre la bonne réponse et le graphe de reconnaissance est la valeur exponentielle de la somme logarithmique de la bonne réponse. En revanche, la valeur exponentielle de la somme des logarithmes au dernier nœud de la composition du graphe entre le graphe de reconnaissance et la grammaire est la valeur marginale de toutes les interprétations valides possibles. -# Equation différentielle ordinaire (ODE) neurale +# Equation différentielle ordinaire (ODE) neuronale En utilisant cette formulation de la rétropropagation, nous pouvons maintenant parler d'une nouvelle classe de modèles, les ODEs neuronales. Il s'agit essentiellement de réseaux récurrents où l'état, $z$, au moment $t$ est donné par $ z_{t+\text{d}t} = z_t + f(z_t, W) dt $, où $ W$ représente un ensemble de paramètres fixes. Cela peut également être exprimé sous la forme d'une équation différentielle ordinaire (sans dérivée partielle) : $\frac{\text{d}z}{\text{d}t} = f(z_t, W)$. -Entraîner un tel réseau en utilisant la formulation lagrangienne est très simple. Si nous avons un objectif, $y$, et que nous voulons que l'état du système atteigne $y$ dans le temps $T$, nous établissons simplement la fonction de coût comme étant la distance entre $z_T$ et $y$. Un autre objectif du réseau pourrait être de trouver un état stable du système, *c'est-à-dire un état qui cesse de changer après un certain point. Mathématiquement, cela équivaut à fixer $\frac{\text{d}z}{\text{d}t} = f(y, W) = 0$. En général, trouver une solution, $y$ à cette équation est beaucoup plus facile que la propagation dans le temps, car le réseau n'a pas besoin de se souvenir du gradient par rapport à l'ensemble de la séquence, et doit seulement minimiser $f$ ou $\lvert f \rvert^2$. Pour plus d'informations sur l'entraînement des ODE neuronales pour atteindre des points fixes, voir [(Lecun88)](http://yann.lecun.com/exdb/publis/pdf/lecun-88.pdf). +Entraîner un tel réseau en utilisant la formulation lagrangienne est très simple. Si nous avons un objectif, $y$, et que nous voulons que l'état du système atteigne $y$ dans le temps $T$, nous établissons simplement la fonction de coût comme étant la distance entre $z_T$ et $y$. Un autre objectif du réseau pourrait être de trouver un état stable du système, c'est-à-dire un état qui cesse de changer après un certain point. Mathématiquement, cela équivaut à fixer $\frac{\text{d}z}{\text{d}t} = f(y, W) = 0$. En général, trouver une solution, $y$ à cette équation est beaucoup plus facile que la propagation dans le temps, car le réseau n'a pas besoin de se souvenir du gradient par rapport à l'ensemble de la séquence, et doit seulement minimiser $f$ ou $\lvert f \rvert^2$. Pour plus d'informations sur l'entraînement des ODE neuronales pour atteindre des points fixes, voir [Le Cun (1988)](http://yann.lecun.com/exdb/publis/pdf/lecun-88.pdf). -### Dropout +### *Dropout* -Le dropout consiste à mettre à zéro un certain nombre de neurones de façon aléatoire pendant l'entraînement. Cela empêche le réseau d'apprendre un chemin singulier de l'entrée à la sortie. De même, en raison de la grande paramétrisation des réseaux de neurones, il est possible pour le réseau de neurones de mémoriser efficacement l'entrée. Cependant, avec le dropout, cela est beaucoup plus difficile car l'entrée est mise dans un réseau différent à chaque fois, puisque le dropout entraîne effectivement un nombre infini de réseaux qui sont différents à chaque fois. Par conséquent, le dropout peut être un moyen efficace de contrôler le surentraînement et d'être plus résistant aux petites variations de l'entrée. +Le *dropout* consiste à mettre à zéro un certain nombre de neurones de façon aléatoire pendant l'entraînement. Cela empêche le réseau d'apprendre un chemin singulier de l'entrée à la sortie. De même, en raison de la grande paramétrisation des réseaux de neurones, il est possible pour le réseau de neurones de mémoriser efficacement l'entrée. Cependant, avec le *dropout*, cela est beaucoup plus difficile car l'entrée est mise dans un réseau différent à chaque fois, puisque le *dropout* entraîne effectivement un nombre infini de réseaux qui sont différents à chaque fois. Par conséquent, le *dropout* peut être un moyen efficace de contrôler le surentraînement et d'être plus résistant aux petites variations de l'entrée.

-Figure 1 : Réseau sans dropout + Figure 1 : Réseau sans dropout

-Figure 2 : Réseau avec dropout + Figure 2 : Réseau avec dropout
Dans PyTorch, nous pouvons fixer un taux de dropout aléatoire des neurones.

-Figure 3 : Code pour le dropout + Figure 3 : Code pour le dropout
-Après l'entraînement, lors de l'inférence, le dropout n'est plus utilisé. Afin de créer le réseau final pour l'inférence, nous faisons la moyenne de tous les réseaux individuels créés pendant le dropout et nous l'utilisons pour l'inférence. Nous pouvons également multiplier tous les poids par 1/1-p$, où $p$ est le taux de dropout. +Après l'entraînement, lors de l'inférence, le *dropout* n'est plus utilisé. Afin de créer le réseau final pour l'inférence, nous faisons la moyenne de tous les réseaux individuels créés pendant le *dropout* et nous l'utilisons pour l'inférence. Nous pouvons également multiplier tous les poids par 1/1-p$, où $p$ est le taux de *dropout*. -## Batch normalisation - -Q. Comment la batch normalisation rend-elle l’entraînement plus efficace ? -A. Nous pouvons utiliser un taux d'apprentissage plus élevé lorsque nous appliquons la batch-norm. +## Normalisation par batch -La batch-norm est utilisée pour empêcher le déplacement des covariables internes d'un réseau neuronal, mais la question de savoir si elle permet réellement d'atteindre cet objectif et quel en est le véritable avantage fait l'objet de nombreux débats. +**Comment la normalisation par batch rend-elle l’entraînement plus efficace ?** +> Nous pouvons utiliser un taux d'apprentissage plus élevé lorsque nous appliquons la normalisation par batch. Elle est utilisée pour empêcher le déplacement des covariables internes d'un réseau neuronal, mais la question de savoir si elle permet réellement d'atteindre cet objectif et quel en est le véritable avantage fait l'objet de nombreux débats.

-Figure 5 : Batch-normalisation + Figure 5 : Batch-normalisation
-La batch normalisation étend essentiellement la logique de normalisation de l'entrée du réseau neuronal à la normalisation de l'entrée de chaque couche cachée du réseau. L'idée de base est d'avoir une distribution fixe qui alimente chaque couche suivante d'un réseau neuronal puisque l'apprentissage se fait mieux lorsque nous avons une distribution fixe. Pour ce faire, nous calculons la moyenne et la variance de chaque batch avant chaque couche cachée et nous normalisons les valeurs entrantes par ces statistiques spécifiques aux batchs, ce qui réduit la quantité par laquelle les valeurs vont finalement se déplacer pendant l'entraînement. +> La normalisation par batch étend essentiellement la logique de normalisation de l'entrée du réseau neuronal à la normalisation de l'entrée de chaque couche cachée du réseau. L'idée de base est d'avoir une distribution fixe qui alimente chaque couche suivante d'un réseau neuronal puisque l'apprentissage se fait mieux lorsque nous avons une distribution fixe. Pour ce faire, nous calculons la moyenne et la variance de chaque batch avant chaque couche cachée et nous normalisons les valeurs entrantes par ces statistiques spécifiques aux batchs, ce qui réduit la quantité par laquelle les valeurs vont finalement se déplacer pendant l'entraînement. -En ce qui concerne l'effet de régularisation, étant donné que chaque batch est différent, chaque échantillon sera normalisé par des statistiques légèrement différentes en fonction du lot dans lequel il se trouve. Ainsi, le réseau verra différentes versions légèrement modifiées d'une même entrée, ce qui l'aidera à apprendre à être plus robuste contre de légères variations de l'entrée et à éviter le sur-apprentissage. - -Un autre avantage de la batch normalisation est que l'entraînement est beaucoup plus rapide. +> En ce qui concerne l'effet de régularisation, étant donné que chaque batch est différent, chaque échantillon sera normalisé par des statistiques légèrement différentes en fonction du lot dans lequel il se trouve. Ainsi, le réseau verra différentes versions légèrement modifiées d'une même entrée, ce qui l'aidera à apprendre à être plus robuste contre de légères variations de l'entrée et à éviter le surentraînement. +> Un autre avantage de la *batch normalisation* est que l'entraînement est beaucoup plus rapide. -### Transfer learning (TF) et fine-tuning (FT) - -L'apprentissage par transfert (TF) consiste simplement à entraîner un classifieur final en plus d'un réseau pré-entraîné (utilisé généralement dans les cas où les données sont peu nombreuses). +### L'apprentissage par transfert et le *finetuning* -Le fine-tuning (FT) consiste à entraîner également des parties partielles ou complètes du réseau pré-entraîné (utilisé dans les cas où nous disposons de beaucoup de données en général). +L'apprentissage par transfert (TF pour *Transfert learning*) consiste simplement à entraîner un classifieur final en plus d'un réseau pré-entraîné (utilisé généralement dans les cas où les données sont peu nombreuses). -**Q** : En général, quand devrions-nous geler les couches d'un modèle pré entraîné ? +Le *finetuning* (FT) consiste à entraîner également des parties partielles ou complètes du réseau pré-entraîné (utilisé dans les cas où nous disposons de beaucoup de données en général). -**R** : Si nous avons peu de données d'entraînement. +**En général, quand devrions-nous geler les couches d'un modèle pré entraîné ?** +> Si nous avons peu de données d'entraînement. 4 cas généraux : @@ -396,27 +390,27 @@ Le fine-tuning (FT) consiste à entraîner également des parties partielles ou Notez que nous pouvons également utiliser des taux d'apprentissage différents pour les différentes couches afin d'améliorer les performances. -Pour approfondir notre discussion sur le sur-apprentissage et la régularisation, examinons les visualisations ci-dessous. Ces visualisations ont été générées avec le code de [notebook](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/12-regularization.ipynb). +Pour approfondir notre discussion sur le sur-apprentissage et la régularisation, examinons les visualisations ci-dessous. Ces visualisations ont été générées avec le code de la version anglaise de ce [*notebook*](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/12-regularization.ipynb). Une version en français est disponible [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/12-regularization.ipynb).

-Figure 7: Courbes de perte sans dropout + Figure 7 : Courbes de perte sans dropout

-Figure 8: Courbes de perte avec dropout + Figure 8 : Courbes de perte avec dropout

-Figure 9: Effet de la régularisation sur les poids + Figure 9 : Effet de la régularisation sur les poids
-Les figures 7 et 8 nous permettent de comprendre l'effet spectaculaire que le dropout a sur l'erreur de généralisation, c'est-à-dire la différence entre la perte d'entraînement et la perte de validation. Dans la figure 7, sans dropout, il y a un surentraînement évident car la perte d’entraînement est beaucoup plus faible que la perte de validation. Cependant, dans la figure 8, avec le dropout, la perte d’entraînement et la perte de validation se chevauchent presque continuellement, ce qui indique que le modèle se généralise bien à l'ensemble de validation, qui nous sert de substitut pour l'ensemble hors échantillon. Bien entendu, nous pouvons mesurer la performance réelle hors échantillon en utilisant un ensemble de tests de résistance distinct. +Les figures 7 et 8 nous permettent de comprendre l'effet spectaculaire que le *dropout* a sur l'erreur de généralisation, c'est-à-dire la différence entre la perte d'entraînement et la perte de validation. Dans la figure 7, sans *dropout*, il y a un surentraînement évident car la perte d’entraînement est beaucoup plus faible que la perte de validation. Cependant, dans la figure 8, avec le *dropout*, la perte d’entraînement et la perte de validation se chevauchent presque continuellement, ce qui indique que le modèle se généralise bien à l'ensemble de validation, qui nous sert de substitut pour l'ensemble hors échantillon. Bien entendu, nous pouvons mesurer la performance réelle hors échantillon en utilisant un ensemble de tests de résistance distinct. -Dans la figure 9, nous observons l'effet que la régularisation (L1 & L2) a sur les poids du réseau. +Dans la figure 9, nous observons l'effet que la régularisation (L1 et L2) a sur les poids du réseau. - Lorsque nous appliquons la régularisation L1, à partir du pic rouge à zéro, nous pouvons comprendre que la plupart des poids sont nuls. Les petits points rouges plus proches de zéro sont les poids non nuls du modèle. @@ -457,24 +451,24 @@ As you can observe in the above images, these uncertainty estimations are not ca Nous nous soucions de l'incertitude dans les réseaux de neurones car un réseau a besoin de savoir à quel point il est certain/confident de ses prévisions. -Ex : Si vous construisez un réseau de neurones pour prédire le contrôle de la direction, vous devez connaître le degré de confiance des prédictions du réseau. +Par exemple, si vous construisez un réseau de neurones pour prédire le contrôle de la direction, vous devez connaître le degré de confiance des prédictions du réseau. -Nous pouvons utiliser un réseau de neurones avec dropout pour obtenir un intervalle de confiance autour de nos prédictions. Entraînons un réseau avec dropout, $r$ étant le taux de dropout. +Nous pouvons utiliser un réseau de neurones avec *dropout* pour obtenir un intervalle de confiance autour de nos prédictions. Entraînons un réseau avec *dropout*, $r$ étant le taux de *dropout*. Habituellement, lors de l'inférence, nous mettons le réseau en mode de validation et utilisons tous les neurones pour obtenir la prédiction finale. Tout en faisant la prédiction, nous échelonnons les poids $\delta$ par $\dfrac{1}{1-r}$ pour tenir compte des neurones abandonnés pendant l'entraînement. -Cette méthode nous permet d'obtenir une seule prédiction pour chaque entrée. Cependant, pour obtenir un intervalle de confiance autour de notre prédiction, nous avons besoin de plusieurs prédictions pour la même entrée. Ainsi, au lieu de mettre le réseau en mode de validation pendant l'inférence, nous le gardons en mode d'entraînement c'est-à-dire que nous faisons toujours tomber des neurones de manière aléatoire et obtenons une prédiction. Lorsque nous faisons plusieurs prédictions en utilisant ce réseau de dropout, pour la même entrée, nous obtiendrons des prédictions différentes selon les neurones qui sont dropés. Nous utilisons ces prédictions pour estimer la prédiction finale moyenne et un intervalle de confiance autour de celle-ci. +Cette méthode nous permet d'obtenir une seule prédiction pour chaque entrée. Cependant, pour obtenir un intervalle de confiance autour de notre prédiction, nous avons besoin de plusieurs prédictions pour la même entrée. Ainsi, au lieu de mettre le réseau en mode de validation pendant l'inférence, nous le gardons en mode d'entraînement c'est-à-dire que nous faisons toujours tomber des neurones de manière aléatoire et obtenons une prédiction. Lorsque nous faisons plusieurs prédictions en utilisant ce réseau de *dropout*, pour la même entrée, nous obtiendrons des prédictions différentes selon les neurones qui sont dropés. Nous utilisons ces prédictions pour estimer la prédiction finale moyenne et un intervalle de confiance autour de celle-ci. -Dans les images ci-dessous, nous avons estimé les intervalles de confiance autour des prédictions des réseaux. Ces visualisations ont été générées avec le code du [notebook « Bayesian Neural Network »](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/13-bayesian_nn.ipynb). La ligne rouge représente les prédictions. La région en violet autour des prédictions représente l'incertitude c'est-à-dire la variance des prédictions. +Dans les images ci-dessous, nous avons estimé les intervalles de confiance autour des prédictions des réseaux. Ces visualisations ont été générées avec la version anglaise de ce [notebook](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/13-bayesian_nn.ipynb). Une version en français est disponible [ici](https://github.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/blob/master/13-bayesian_nn..ipynb). La ligne rouge représente les prédictions. La région en violet autour des prédictions représente l'incertitude c'est-à-dire la variance des prédictions.

-Figure 10: Estimation de l'incertitude en utilisant l'activation ReLU + Figure 10 : Estimation de l'incertitude en utilisant l'activation ReLU

-Figure 11: Estimation de l'incertitude en utilisant l'activation Tanh + Figure 11 : Estimation de l'incertitude en utilisant l'activation Tanh
@@ -493,7 +487,7 @@ In EBM models, we can simply and conveniently sum the different terms to estimat Dans les modèles EBM, nous pouvons simplement et commodément additionner les différents termes pour estimer la perte totale. -**Digression** : Un terme qui pénalise la longueur de la variable latente peut agir comme l'un des nombreux termes de perte dans un modèle. La longueur d'un vecteur est à peu près proportionnelle au nombre de dimensions qu'il possède. Ainsi, si vous diminuez le nombre de dimensions, la longueur du vecteur diminue et, par conséquent, il code moins d'informations. Dans un paramétrage d'auto-encodeur, cela permet de s'assurer que le modèle conserve les informations les plus importantes. Ainsi, une façon de bloquer l'information dans les espaces latents est de réduire la dimensionnalité de l'espace latent. +**Digression** : un terme qui pénalise la longueur de la variable latente peut agir comme l'un des nombreux termes de perte dans un modèle. La longueur d'un vecteur est à peu près proportionnelle au nombre de dimensions qu'il possède. Ainsi, si vous diminuez le nombre de dimensions, la longueur du vecteur diminue et, par conséquent, il code moins d'informations. Dans un paramétrage d'auto-encodeur, cela permet de s'assurer que le modèle conserve les informations les plus importantes. Ainsi, une façon de bloquer l'information dans les espaces latents est de réduire la dimensionnalité de l'espace latent. #### Comment déterminer l'hyperparamètre pour la régularisation ? -En pratique, pour déterminer l'hyperparamètre optimal pour la régularisation, c'est-à-dire la force de régularisation, nous pouvons utiliser +En pratique, pour déterminer l'hyperparamètre optimal pour la régularisation, c'est-à-dire la force de régularisation, nous pouvons utiliser : - Optimisation des hyperparamètres bayésiens -- Recherche de grille +- Recherche par grille - Recherche aléatoire Lors de ces recherches, les premières époques sont généralement suffisantes pour nous donner une idée du fonctionnement de la régularisation. Nous devons donc entraîner le modèle de façon intensive. diff --git a/docs/fr/week14/14.md b/docs/fr/week14/14.md index f6d910bcd..7d3991abc 100644 --- a/docs/fr/week14/14.md +++ b/docs/fr/week14/14.md @@ -13,9 +13,9 @@ In this section, we discussed the structured prediction. We first introduced the --> -## Conférence partie A +## Cours magistral partie A -Dans cette section, nous discutons de la prédiction structurée. Nous présentons d'abord le graphe des facteurs à base d’énergie et l'inférence efficace pour celui-ci. Ensuite, nous donnons quelques exemples simples avec des facteurs "peu profonds". Enfin, nous discutons du réseau transformer de graphe. +Dans cette section, nous discutons de prédiction utilisant la structure. Nous présentons d'abord le graphe factoriel à base d’énergie et l'inférence efficace pour celui-ci. Ensuite, nous donnons quelques exemples simples avec des facteurs peu profonds. Enfin, nous discutons du *Graph Transformer Network* (GTN). -## Conférence partie B +## Cours magistral partie B -La deuxième partie de la conférence traite plus en détail de l'application des méthodes de modélisation graphique aux modèles à base d’énergie. Après avoir passé un certain temps à comparer différentes fonctions de perte, nous discutons de l'application de l'algorithme de Viterbi et de l'algorithme de retransmission aux réseaux transformer de graphe. Nous passons ensuite à la discussion de la formulation lagrangienne de la rétropropagation, puis à l'inférence variationnelle pour les EBM. +La deuxième partie du cours traite plus en détail de l'application des méthodes de modélisation graphique aux modèles à base d’énergie (EBMs). Après avoir passé un certain temps à comparer différentes fonctions de perte, nous discutons de l'application de l'algorithme de Viterbi et de l'algorithme *forward* aux GTNs. Nous passons ensuite à la discussion de la formulation lagrangienne de la rétropropagation, puis à l'inférence variationnelle pour les EBMs. -## Pratique -Lors de l’entraînement de modèles hautement paramétrés tels que les réseaux neuronaux profonds, il existe un risque de surentraînement des données d’entraînement. Cela conduit à une plus grande erreur de généralisation. Pour aider à réduire cela, nous pouvons introduire une régularisation dans notre entraînement, en décourageant certaines solutions pour diminuer la mesure dans laquelle nos modèles s'adapteront au bruit. - - - +## Travaux dirigés +Lors de l’entraînement de modèles hautement paramétrés tels que les réseaux neuronaux profonds, il existe un risque de surentraînement sur les données d’entraînement. Cela conduit à une plus grande erreur de généralisation. Pour aider à réduire cela, nous pouvons introduire une régularisation dans notre entraînement, en décourageant certaines solutions pour diminuer la mesure dans laquelle nos modèles s'adapteront au bruit. diff --git a/docs/fr/week14/lecture14.sbv b/docs/fr/week14/lecture14.sbv index 26ea4c71e..1a41f9ea5 100644 --- a/docs/fr/week14/lecture14.sbv +++ b/docs/fr/week14/lecture14.sbv @@ -20,7 +20,7 @@ l’IA, l’apprentissage profonde, etc. Peut-être des questions laissez-moi commencer par quelque chose de plus concret. 0:00:25.000,0:00:28.800 -Donc je veux parler de la prédiction de structure. J'ai fait allusion à ce sujet de +Donc je veux parler de la prédiction utilisant la structure. J'ai fait allusion à ce sujet de 0:00:28.800,0:00:33.360 nombre de fois au cours des cours précédents, mais je pense que ce n'était pas suffisamment @@ -29,7 +29,7 @@ nombre de fois au cours des cours précédents, mais je pense que ce n'était pa en profondeur pour que la plupart des gens puissent comprendre. Donc je veux 0:00:36.880,0:00:42.079 -revenir sur ce point. Donc la prédiction de structure est en gros +revenir sur ce point. Donc la prédiction utilisant la structure est en gros 0:00:42.079,0:00:47.200 le problème de prédire une variable qui elle-même n'est pas @@ -67,7 +67,7 @@ car c'est combinatoire, il n'y a pas moyen d'énumérer toutes les sorties différentes possibles. Donc pour exprimer le type de contrainte que la sortie a 0:01:38.560,0:01:42.640 -à refléter, c’est ce qu'on appelle la prédiction de structure. +à refléter, c’est ce qu'on appelle la prédiction utilisant la structure. 0:01:42.640,0:01:49.600 Il y a beaucoup de travail sur ça, datant dès les premiers jours de la reconnaissance vocale. @@ -79,7 +79,7 @@ Ce n'est donc pas un problème récent. Et en fait le je vais commencer par un peu d'histoire. 0:01:57.920,0:02:01.680 -A mon avis, le premier modèle à faire de la prédiction de structure +A mon avis, le premier modèle à faire de la prédiction en utilisant la structure 0:02:01.680,0:02:04.079 avec des choses combinées à des réseaux neurones @@ -115,7 +115,7 @@ Ce réseau ici, TDNN, signifiant « Time Data Neural Net » [réseau neuronal de données temporelles] est en gros un réseau convolutif temporel. 0:02:46.160,0:02:56.080 -C’est donc le premier modèle que je peux trouver sur des prédictions de structure étant, en quelque sorte, +C’est donc le premier modèle que je peux trouver sur des prédictions utilisant la structure étant, en quelque sorte, 0:02:56.080,0:02:58.080 hybridé avec des réseaux neuronaux. @@ -538,13 +538,13 @@ comme vous indiquant laquelle des réponses est la bonne. Donc ce n'est rien de plus qu'un modèle basé sur l'énergie. 0:12:57.120,0:13:01.480 -Alors pourquoi je présente ça avant de parler +Alors pourquoi je présente ça avant de parler de 0:13:01.480,0:13:04.750 -de la prédiction de structure ? Car il s'agit d'une +prédiction utilisant la structure ? Car il s'agit d'une 0:13:04.750,0:13:08.320 -forme simple de prédiction de structure, surtout si le problème n'est pas +forme simple de prédiction utilisant la structure, surtout si le problème n'est pas 0:13:08.320,0:13:12.399 de reconnaître un seul mot mais de reconnaître une séquence de mots. @@ -592,7 +592,7 @@ qui est composé d'une entrée x, il prend une entrée x. C'est un modèle d’énergie dans lequel l'énergie est une somme de trois termes dans ce cas. 0:14:29.600,0:14:36.880 -Donc ces carrés bleus ici sont en gros les facteurs dans un graphe de facteurs, +Donc ces carrés bleus ici sont en gros les facteurs dans un graphe factoriel, 0:14:36.880,0:14:40.079 des termes d'énergie additifs dans votre fonction d’énergie. @@ -721,7 +721,7 @@ et y est observé pendant l’entraînement à droite. Toutes les variables inte intermédiaires ne sont jamais observées, ce sont des variables latentes dont vous avez besoin pour minimiser. 0:17:54.400,0:18:00.799 -Mais ici encore, ce graphe de facteurs est factorisé au sens que l'énergie est une somme de différents +Mais ici encore, ce graphe factoriel est factorisé au sens que l'énergie est une somme de différents 0:18:00.799,0:18:06.640 termes qui ne prennent en compte que des sous-ensembles des variables. @@ -991,10 +991,10 @@ vous essayez de la faire baisser et puis vous prenez les énergies des réponses incorrectes et essayez de les rendre plus grandes. C'est un 0:26:13.919,0:26:17.919 -entraînement discriminatoire pour la prédiction de structure. +entraînement discriminatoire pour la prédiction utilisant la structure. 0:26:17.919,0:26:22.720 -Prédiction de structure car la structure ici est représentée par cette +Prédiction utilisant la structure car la structure ici est représentée par cette 0:26:22.720,0:26:28.320 séquence de coûts. Mais conceptuellement, à un niveau élevé, ce n'est pas @@ -1387,7 +1387,7 @@ littérature vous saurez ce que c'est : cela s'appelle un champ aléatoire conditionnel. Un champ aléatoire conditionnel 0:36:22.000,0:36:27.119 -est un type très particulier de modèle de prédiction de structure. +est un type très particulier de modèle de prédiction utilisant la structure. 0:36:27.119,0:36:30.880 Ici vous avez les Y de Z, cela n’a pas d'importance. @@ -1492,7 +1492,7 @@ réponses de l'exponentielle moins les énergies. Donc ici le champ aléatoire conditionnel est en gros un exemple de cela mais 0:39:00.000,0:39:03.200 -vous ne faites pas de classification. Vous faites une sorte de prédiction de structure. +vous ne faites pas de classification. Vous faites une sorte de prédiction utilisant la structure. 0:39:03.200,0:39:07.200 Dans le cas positif, vous avez la bonne configuration @@ -1576,7 +1576,7 @@ Michael Collins qui est un célèbre professeur en NLP à Columbia à en quelque sorte réussi à construire sa carrière autour de cela. 0:41:03.599,0:41:07.000 -L'idée d'utiliser la perte de perception pour la prédiction de structure. +L'idée d'utiliser la perte de perception pour la prédiction utilisant la structure. 0:41:07.000,0:41:11.200 La perte de perception ne fonctionne que si vous disposez d'une paramétrisation linéaire @@ -1636,7 +1636,7 @@ Alors, comme je l'ai dit, au début des années 90, les gens ont commencé à tr l'utilisation de réseaux neuronaux pour alimenter un de ces systèmes de 0:42:34.240,0:42:38.720 -prédiction de structure. Comme je l'ai dit le premier que je connais est +prédiction utilisant la structure. Comme je l'ai dit le premier que je connais est 0:42:38.720,0:42:41.599 par Xavier Driancourt et Léon Bottou pour la reconnaissance vocale. @@ -1660,7 +1660,7 @@ car je les ai tous les trois embauchés à AT&T pour travailler sur ce problème Ils ont compris comment faire ça dans le cadre de leur thèse et je savais que c'était le truc qui devait être appliqué pour 0:43:18.720,0:43:24.000 -des choses comme la reconnaissance de l'écriture manuscrite, la prédiction de structure avec les réseaux neuronaux. +des choses comme la reconnaissance de l'écriture manuscrite, la prédiction utilisant la structure avec les réseaux neuronaux. 0:43:31.280,0:43:38.240 Donc voici quelque chose dont j'ai fait rapidement allusion dans un cours précédent. @@ -1741,7 +1741,7 @@ Le 2 suivant être regroupé et puis le dernier est lui-même. Donc qu'est-ce que j'ai fait ici ? 0:45:44.560,0:45:51.040 -La façon dont j'ai fait l’inférence dans le contexte de la prédiction de structure +La façon dont j'ai fait l’inférence dans le contexte de la prédiction utilisant la structure 0:45:51.040,0:45:59.359 c'est en ayant des termes énergétiques qui me disent @@ -2176,7 +2176,7 @@ Et bien il y aura une deuxième phase où, dans ce cas, nous allons juste laisser le système choisir la réponse qu'il veut. 0:56:37.119,0:56:46.240 -C'est une sorte de forme simplifiée d’entraînement discriminant pour la prévision de structure. +C'est une sorte de forme simplifiée d’entraînement discriminant pour la prédiction utilisant la structure. 0:56:46.240,0:56:51.040 Cela utilise une forme de perte de perceptron si vous voulez. @@ -2590,7 +2590,7 @@ j’ai expliquée. Vous prenez juste l’entrée et ne la segmentez jamais. Il suffit d'appliquer le réseau neuronal à chaque emplacement de l'entrée 1:06:47.599,1:06:51.599 -enregistrer la sortie. Puis faire une prédiction de structure au-dessus de ça. +enregistrer la sortie. Puis faire une prédiction utilisant la structure au-dessus de ça. 1:06:51.599,1:06:55.599 Donc vous devez avoir une sorte de modèle de séquence qui vous dit : diff --git a/docs/fr/week15/15-1.md b/docs/fr/week15/15-1.md index df5afa8c0..766cdd5e3 100644 --- a/docs/fr/week15/15-1.md +++ b/docs/fr/week15/15-1.md @@ -2,7 +2,7 @@ lang: fr lang-ref: ch.15-1 lecturer: Alfredo Canziani -title: Inférence pour les modèles à base d’énergie à varaible latente +title: Inférence pour les modèles à base d’énergie à variable latente authors: Yilang Hao, Binfeng Xu, Ebrahim Rasromani, Mars Wei-Lun Huang date: 18 Oct 2020 translation-date: 6 Dec 2020 @@ -79,7 +79,7 @@ $$ $$ où $x \sim \mathcal{U}(0,1),\space \theta \sim \mathcal{U}(0,2\pi),\space \epsilon \sim \mathcal{N}[0, (\frac{1}{20})^2]$ -et $\rho : \mathbb{R} \mapsto \mathbb{R}^2$ maps $x$ into $$\begin{bmatrix}\alpha x + \beta (1-x) \\ +et $\rho : \mathbb{R} \mapsto \mathbb{R}^2$ associe $x$ à $$\begin{bmatrix}\alpha x + \beta (1-x) \\ \beta x + \alpha (1-x) \end{bmatrix}\exp(2x)$$. @@ -90,26 +90,26 @@ et $\rho : \mathbb{R} \mapsto \mathbb{R}^2$ maps $x$ into $$\begin{bmatrix}\alp
-La figure 1 montre clairement qu'avec une seule entrée $x$, il y a plusieurs sorties possibles $\vect{y}$. En d'autres termes, nous ne pouvons pas identifier un mappage un à un des vecteurs comme nous l'avions prévu pour les réseaux neuronaux de type feed forward (par exemple, il y a presque toujours deux $y_2$ possibles avec $y_1$ fixé et étant donné l'entrée $x$). C'est ici que nous introduisons les modèles à base d’énergie à variable latente. +La figure 1 montre clairement qu'avec une seule entrée $x$, il y a plusieurs sorties possibles $\vect{y}$. En d'autres termes, nous ne pouvons pas identifier une association un à un des vecteurs comme nous l'avions prévu pour les réseaux neuronaux de type feed forward (par exemple, il y a presque toujours deux $y_2$ possibles avec $y_1$ fixé et étant donné l'entrée $x$). C'est ici que nous introduisons les modèles à base d’énergie à variable latente. Pour simplifier, nous fixons l'entrée $x = 0$ et nous laissons $\alpha = 1,5, \beta = 2$, induisant $$\vect{y} = \begin{bmatrix} 2\cos(\theta) + \epsilon \\ 1.5\sin(\theta) + \epsilon \end{bmatrix}$$, à partir de laquelle nous échantillonnons aléatoirement 24 points de données $Y = [\vect{y}^{(1)},\ldots,\vect{y}^{(24)}]$. -Entre-temps, nous prenons la variable latente $z = [0:\frac{\pi}{24}:2\pi)$ et l'introduisons dans un décodeur pour produire $\tilde{\vect{y}}$ (figures 2 et 3). +Entre-temps, nous prenons la variable latente $z = [0:\frac{\pi}{24}:2\pi]$ et l'introduisons dans un décodeur pour produire $\tilde{\vect{y}}$ (figures 2 et 3). Ensuite, la fonction d'énergie est calculée comme le carré de la distance euclidienne entre $\vect{y}$ et $\tilde{\vect{y}}$ : $$ E(\vect{y},z) \equiv E(\vect{y},\tilde{\vect{y}}(z)) = [y_1 - g_1(z)]^2 + [y_2 - g_2(z)]^2, \space \vect{y} \in Y, $$ -où $\vect{g} = [g_1 \space\space g_2]^{\top} : \mathbb{R} \mapsto \mathbb{R}^2$ and $\vect{g}(z) = \ [w_1 \cos(z) \space\space w_2 \sin(z)]^{\top}$. +où $\vect{g} = [g_1 \space\space g_2]^{\top} : \mathbb{R} \mapsto \mathbb{R}^2$ et $\vect{g}(z) = \ [w_1 \cos(z) \space\space w_2 \sin(z)]^{\top}$.

Figure 2 : Exemple de visualisation
- +

Figure 3 : Graphique du calcul de l'énergie @@ -203,7 +203,7 @@ Nous exprimerons également la variable latente qui donne l'énergie libre sous $$\check{z} = \arg \min_{z} E(\vect{y}, z)$$ Comme le montre la figure 5, pour trouver l'énergie libre associée à $\vect{y}^{(23)}$, nous commençons par une variable initiale latente $\tilde{z}$. -$\check{z}$ peut être évalué par des algorithmes d'optimisation tels que la recherche exhaustive, le gradient conjugué, la recherche de lignes ou le BFGS à mémoire limitée. +$\check{z}$ peut être évalué par des algorithmes d'optimisation tels que la recherche exhaustive, le gradient conjugué, la recherche linéaire ou le BFGS à mémoire limitée. L'énergie libre est la valeur minimale de l'énergie par rapport à la variable latente. La figure 7 ci-dessous montre l'évaluation de l'énergie libre dans l'espace $\vect{y}$. @@ -281,7 +281,7 @@ Pour mieux comprendre la fonction d’énergie libre, nous commençons par l'exe

-Pour calculer l'énergie libre, $F_\infty$, à chaque point de grille de maille par rapport à la variété en bleue (qui est également l'ensemble des choix possibles des variables latentes $z$), nous rappelons d'abord la définition de la fonction d'énergie libre ci-dessous : +Pour calculer l'énergie libre, $F_\infty$, à chaque point de la grille de maille par rapport à la variété en bleue (qui est également l'ensemble des choix possibles des variables latentes $z$), nous rappelons d'abord la définition de la fonction d'énergie libre ci-dessous : $$ F_\infty = \min_z E(\vect{y},z) = E(\vect{y},\check{z}). @@ -291,11 +291,11 @@ $$ Sur le graphique de la figure 8, nous commençons par un point arbitraire $z$ sur la variété en bleue, puis nous nous déplaçons autour pour trouver sur la variété le point $\check{z}$ qui est le plus proche de notre emplacement (échantillon), $\vect{y}$. Par conséquent, l'énergie libre est la distance euclidienne entre notre point d'échantillonnage $\vect{y}$ et le point choisi $\tilde{\vect{y}}(\check{z})$. -Maintenant, nous considérons 5 points échantillons spécifiques dans la grille de maillage, illustrés sur la figure 9 avec des couleurs différentes. +Maintenant, nous considérons 5 points échantillons spécifiques dans la grille de maille, illustrés sur la figure 9 avec des couleurs différentes.

-Figure 9 : Cinq points d'échantillonnage sur la grille de maillage +Figure 9 : Cinq points d'échantillonnage sur la grille de maille

@@ -311,11 +311,11 @@ L'aspect complet des cinq fonctions d’énergie est donné comme suit dans la f
En poursuivant l'exemple ci-dessus, nous devons noter que notre fonction d'énergie libre, $F_\infty$, ne prend que des valeurs scalaires non négatives pour son domaine (parce que nous utilisons la distance euclidienne pour $E(\vect{y},z)$), et le domaine de notre fonction d'énergie libre, $F_\infty$, est $\mathbb{R}^2$ (seulement l'espace $\vect{y}$), donc généralement nous avons $F_\infty : \mathbb{R}^2 \rightarrow \mathbb{R}^+$. -Nous utilisons maintenant les valeurs d'énergie libre comme inférence pour tracer la grille de maillage comme la carte thermique illustrée à la figure 11.À noter que les flèches représentent les valeurs de gradient. +Nous utilisons maintenant les valeurs d'énergie libre comme inférence pour tracer la grille de maille comme la carte thermique illustrée à la figure 11. À noter que les flèches représentent les valeurs de gradient.

-Figure 11: Carte thermique de l’énergie libre +Figure 11 : Carte thermique de l’énergie libre

@@ -343,14 +343,12 @@ One typical example is language translation. We can translate a sentence in diff If the model has learnt from the real manifold, then you can find the denoised version of your input by minimizing energy. --> -## Questions et réponses sur la compréhension -#### Question 1 : Pourquoi la surface énergétique est-elle évaluée de manière scalaire ? -La surface énergétique, qui prend la valeur de l'énergie libre, $F_\infty$, est exactement la valeur minimale de notre fonction d’énergie $E(\vect{y},z)$ parmi toutes les variables latentes possibles, $z$. Par conséquent, $F_\infty$ ne dépend pas de $z$, mais seulement de $\vect{y}$, qui produit une valeur scalaire pour chaque choix de $\vect{y}$. -En considérant l'exemple de maillage ci-dessus, le maillage a $17\times 25 = 425$ points, nous avons donc 425 valeurs d'énergie libre et chaque valeur est la distance euclidienne quadratique de chaque point de la variété. +## Réponses aux questions des étudiants +**Question 1 : Pourquoi la surface énergétique est-elle évaluée de manière scalaire ?** +> La surface énergétique, qui prend la valeur de l'énergie libre, $F_\infty$, est exactement la valeur minimale de notre fonction d’énergie $E(\vect{y},z)$ parmi toutes les variables latentes $z$ possibles. Par conséquent, $F_\infty$ ne dépend pas de $z$, mais seulement de $\vect{y}$, qui produit une valeur scalaire pour chaque choix de $\vect{y}$. En considérant l'exemple de maillage ci-dessus, le maillage a $17\times 25 = 425$ points, nous avons donc 425 valeurs d'énergie libre et chaque valeur est la distance euclidienne quadratique de chaque point de la variété. -#### Question 2 : Comment choisissez-vous la fonction pour représenter la variété ? -Il existe de nombreuses recherches sur les choix de la variable latente et nous pouvons avoir quelques couches de réseaux de neurones pour représenter les choix des variables latentes. -Un exemple typique est celui de la traduction linguistique. Nous pouvons traduire une phrase de différentes manières et nous ne pouvons pas utiliser une fonction softmax pour l'entraînement de notre modèle car il y aura une infinité de phrases possibles après la traduction. Par conséquent, nous pouvons utiliser ici l'EBM et la fonction d'énergie nous dit dans quelle mesure la phrase originale et la phrase traduite sont compatibles. +**Question 2 : Comment choisir la fonction pour représenter la variété ?** +> Il existe de nombreuses recherches sur les choix de la variable latente et nous pouvons avoir quelques couches de réseaux de neurones pour représenter les choix des variables latentes. Un exemple typique est celui de la traduction linguistique. Nous pouvons traduire une phrase de différentes manières et nous ne pouvons pas utiliser une fonction softmax pour l'entraînement de notre modèle car il y aura une infinité de phrases possibles après la traduction. Par conséquent, nous pouvons utiliser ici l'EBM et la fonction d'énergie nous dit dans quelle mesure la phrase originale et la phrase traduite sont compatibles. -#### Question 3 : Est-ce que la minimisation de l'énergie par rapport à la variété entraînée signifie-t-elle débruitage ? -Si le modèle a tiré des leçons de la variété réelle, vous pouvez trouver la version débruitée de votre entrée en minimisant l'énergie. +**Question 3 : Est-ce que la minimisation de l'énergie par rapport à la variété entraînée signifie-t-elle débruitage ?** +> Si le modèle a tiré des leçons de la variété réelle, vous pouvez trouver la version débruitée de votre entrée en minimisant l'énergie. diff --git a/docs/fr/week15/15-2.md b/docs/fr/week15/15-2.md index 1b17ebeeb..d8e291838 100644 --- a/docs/fr/week15/15-2.md +++ b/docs/fr/week15/15-2.md @@ -37,23 +37,23 @@ If we take $y_2=0.4$, then $F_\beta(\vect{y})=0$ and as we move linearly away fr --> ## [Énergie libre](https://www.youtube.com/watch?v=XLSb1Cs1Jao&t=11s) -L'énergie libre: +L'énergie libre : $$F_\infty (\vect{y})=\min_z E(\vect{y},z) = E(\vect{y},\check z)$$ -Ici, $F_\infty$ est la limite de la température zéro de l'énergie libre et $\vect{y}$ est un vecteur 2D. Cette énergie libre est la distance euclidienne quadratique par rapport à la variété du modèle. Tous les points qui se trouvent dans la variété du modèle ont une énergie nulle. En s'éloignant, elle augmente de façon quadratique. +Ici, $F_\infty$ est la limite vers zéro de la température de l'énergie libre et $\vect{y}$ est un vecteur 2D. Cette énergie libre est la distance euclidienne quadratique par rapport à la variété du modèle. Tous les points qui se trouvent dans la variété du modèle ont une énergie nulle. En s'éloignant, elle augmente de façon quadratique.

-Figure 1 : Carte en couleur froid-chaud +Figure 1 : Carte thermique froid-chaud
-Froid : $F_\infty = 0$, chaud : $F_\infty = 0,5$, chaud : $F_\infty \geq 1$ +Froid : $F_\infty = 0$, chaud : $F_\infty = 0,5$, brûlant : $F_\infty \geq 1$ -Toutes les régions autour de l'ellipse qui se trouve avec la multiplicité des ellipses ont une énergie nulle. -Au centre, il y a une énergie libre infinie de limite de température zéro. Pour éviter cela, nous devons détendre l'énergie libre à une énergie sans minima locaux afin qu'elle devienne plus régulière. +Toutes les régions autour de l'ellipse qui se trouve avec la variété en ellipse ont une énergie nulle. +Au centre, il y a une limite vers zéro de la température de l'énergie libre qui est infinie. Pour éviter cela, nous devons détendre l'énergie libre à une énergie sans minima locaux afin qu'elle devienne plus lisse. -Regardons de plus près $y_1=0$, avec la carte froid-chaud suivante : +Regardons de plus près $y_1=0$, avec la carte themrique suivante :

@@ -131,7 +131,7 @@ où $\beta=(k_B T)^{-1}$ est la température inverse, constituée de la constant $$\tilde{F}_\beta(\vect{y})=-\frac{1}{\beta} \log \frac{1}{\vert\mathcal{Z}\vert}\underset{z\in\mathcal{Z}}{\sum} \exp[{-\beta}E(y,z)]\Delta z$$ -Ici, nous définissons $-\frac{1}{\beta} \log \frac{1}{\vert\mathcal{Z}\vert}\underset{z\in\mathcal{Z}}{\sum} \exp[{-\beta}E(\vect{y},z)]$ pour être le $\smash{\underset{z}{\text{softmin}}}_\beta[E(\vect{y},z)]$, de sorte que l'assouplissement de la limite de température zéro de l'énergie libre devienne le *réel*-softmin. +Ici, nous définissons $-\frac{1}{\beta} \log \frac{1}{\vert\mathcal{Z}\vert}\underset{z\in\mathcal{Z}}{\sum} \exp[{-\beta}E(\vect{y},z)]$ pour être le $\smash{\underset{z}{\text{softmin}}}_\beta[E(\vect{y},z)]$, de sorte que la relaxation de la limite vers zéro de la température de l'énergie libre devienne le softmin *réel*. **Exemples :** @@ -204,7 +204,7 @@ In technical terms, if free energy is ## Nomenclature et PyTorch -Formellement, nous définissons le réel-softmax comme : +Formellement, nous définissons le softmax *réel* comme : $$\smash{\underset{z}{\text{softmax}}}_\beta[E(y,z)] \doteq \frac{1}{\beta} \log \underset{z\in\mathcal{Z}}{\sum} \exp[{\beta}E(\vect{y},z)] - \frac{1}{\beta} \log{N_z}$$ @@ -214,7 +214,7 @@ Pour implémenter la fonction ci-dessus dans PyTorch, nous utilisons `torch.logs $$\smash{\underset{z}{\text{softmax}}}_\beta[E(y,z)] \doteq \frac{1}{\beta} \texttt{torch.logsumexp}({\beta}E(\vect{y},z),\texttt{dim=}z) - \frac{1}{\beta} \log{N_z}$$ -réel-softmin : +Le softmin *réel* : $$\smash{\underset{z}{\text{softmin}}}_\beta[E(y,z)] \doteq -\frac{1}{\beta}\log\frac{1}{N_z}\underset{z\in\mathcal{Z}}{\sum}\exp[-{\beta}E(\vect{y},z)]$$ @@ -224,9 +224,9 @@ $$\smash{\underset{z}{\text{softmin}}}_\beta[E(y,z)] = -\smash{\underset{z}{\tex $$\texttt{torch.softmax}(l(j),\texttt{dim=j}) = \smash{\underset{j}{\text{softargmax}_{\beta=1}}}[l(j)]$$ -En termes techniques, si l'énergie libre est -- chaude, cela fait référence à la moyenne. -- tiède, cela se réfère à la marginalisation de la latente. +En termes techniques, si l'énergie libre est : +- brûlante, cela fait référence à la moyenne. +- chaude, cela se réfère à la marginalisation de la latente. - froide, cela se réfère à la valeur minimale. @@ -306,30 +306,30 @@ La fonction d’énergie doit être petite pour les données qui proviennent de $$l_{\text{hinge}}(F(\cdot),\check{\vect{y}},\hat{\vect{y}}) = \big(m - [F(\hat{\vect{y}})-F(\check{\vect{y}})]\big)^{+}$$ -où $m$ est la marge et $F(\check{\vect{y}})$ et $F(\hat{\vect{y}})$ sont les énergies libres pour les énergies "froides" (pour les étiquettes correctes) et "chaudes" (pour les étiquettes incorrectes) respectivement. +où $m$ est la marge et $F(\check{\vect{y}})$ et $F(\hat{\vect{y}})$ sont les énergies libres pour les énergies froides (pour les étiquettes correctes) et chaudes (pour les étiquettes incorrectes) respectivement. Le modèle essaie de faire en sorte que la différence entre deux énergies soit supérieure à la marge $m$. Il existe une fonction `ReLU` $[\cdot]^{+}$ utilisée sur la sortie de $m - [F(\hat{\vect{y}}) - F(\check{\vect{y}})]$, ce qui signifie que la valeur de cette fonction de perte *hinge* sera toujours non négative. Cela implique que s'il y a des valeurs négatives, elles deviendront nulles en raison de cette fonction. -L’entraînement rend $F(\hat{\vect{y}}})-F(\check{\vect{y}})$ égal ou supérieur à $m$. +L’entraînement rend $F(\hat{\vect{y}}) - F(\check{\vect{y}})$ égal ou supérieur à $m$. Si la différence devient supérieure à $m$, la valeur globale de $[m - [F(\hat{\vect{y}}) - F(\check{\vect{y}})]]$ devient négative, la perte *hinge* devient nulle. On peut aussi dire que nous poussons les énergies tant que la différence est inférieure à $m$. Cependant, si la différence devient supérieure à la marge $m$, nous cessons de pousser. La fonction de perte *hinge* n'a pas une marge lisse. La fonction de perte de logarithme a une marge lisse, comme indiqué ci-dessous : $$l_{\log}(F(\cdot),\check{\vect{y}},\hat{\vect{y}}) = \log(1+\exp[F(\check{\vect{y}})-F(\hat{\vect{y}})]) $$ -Comme nous avons une fonction exponentielle, cette perte a une marge plus lisse. En d'autres termes, elle semble être une version "douce" de la perte hinge avec une marge infinie. +Comme nous avons une fonction exponentielle, cette perte a une marge plus lisse. En d'autres termes, elle semble être une version "douce" de la perte *hinge* avec une marge infinie.

Figure 7
-Le côté gauche est la version non entraînée où, pour chaque point d’entraînement, il y a un x correspondant qui est, sur la surface du modèle, l'emplacement le plus proche du point d’entraînement. +Le côté gauche est la version non entraînée où, pour chaque point d’entraînement, il y a un *x* correspondant qui est, sur la surface du modèle, l'emplacement le plus proche du point d’entraînement. Pendant l’entraînement à la ZTL (*Zero Temperature Limit*), le gradient fait que le point de données sur la variété qui est le plus proche du point d’entraînement est poussé vers le point d’entraînement. -On peut voir qu'après une époque sur l'image de droite, la version entraînée du modèle montre les x points pour arriver à l'endroit désiré. L'énergie passe à zéro correspondant ainsi aux points d'entraînement (points bleus dans la figure). +On peut voir qu'après une époque sur l'image de droite, la version entraînée du modèle montre les *x* points pour arriver à l'endroit désiré. L'énergie passe à zéro correspondant ainsi aux points d'entraînement (points bleus dans la figure). Lorsque le modèle est entraîné à la ZTL et que la température est augmentée, les points sont choisis individuellement pour être poussés vers le point d’entraînement. Cependant, en cas de marginalisation, si nous choisissons un point $\vect{y}$ (le point vert en croix sur l'image en bas à gauche), le gradient est juste la moyenne de toutes les flèches pointant vers ce point particulier $\vect{y}$). Tous les points sont tirés vers $\vect{y}$, en s'assurant que cela ne surcharge pas les données d'entraînement. La version entraînée ne s'adapte pas à tous les points d’entraînement. @@ -442,7 +442,7 @@ $z$ prend des valeurs de façon linéaire, et est introduit dans le décodeur po $$x = [0:\frac{1}{50} :1]$$ -Le prédicteur prend le x observé, et donne le résultat au décodeur. +Le prédicteur prend le *x* observé, et donne le résultat au décodeur. Nous effectuons un entraînement de l'énergie sans température zéro, ce qui donne un résultat :
diff --git a/docs/fr/week15/15.md b/docs/fr/week15/15.md index fc2abb013..0a7933dc2 100644 --- a/docs/fr/week15/15.md +++ b/docs/fr/week15/15.md @@ -18,7 +18,7 @@ Then, we applied latent-variable EBMs to inference the best latent variables tha ## Travaux dirigés partie A Lorsque les réseaux *feed-forward* rencontrent des données à sorties multiples pour une seule entrée, ils ne peuvent pas saisir les dépendances implicites. -C’est pourquoi les modèles à base d'énergie à variable latente (LV-EBMs pour *Latent variable energy based models*) viennent à la rescousse. +C’est là que les modèles à base d'énergie à variable latente (LV-EBMs pour *Latent variable energy based models*) viennent à la rescousse. Nous développons un exemple d'ellipse avec une entrée fixe et la formulation optimale du modèle. Ensuite, nous appliquons les EBMs à variables latentes pour inférer les meilleures variables latentes pouvant apprendre les relations implicites. @@ -32,6 +32,6 @@ Finally we give a concrete example of self-supervised learning, where we train a --> ## Travaux dirigés partie B -Cette section introduit une version détendue de l'énergie libre en modifiant la "température" pour lisser la fonction d’énergie. +Cette section introduit une version détendue de l'énergie libre en modifiant la "température" afin de lisser la fonction d’énergie. Ensuite, nous montrons comment entraîner les EBMs en minimisant les pertes fonctionnelles à l'aide de plusieurs exemples. Enfin, nous donnons un exemple concret d'apprentissage autosupervisé, où nous entraînons un EBM à l'apprentissage d'une variété de type conique. diff --git a/docs/fr/week15/practicum15A.sbv b/docs/fr/week15/practicum15A.sbv index 84104940e..94673517c 100644 --- a/docs/fr/week15/practicum15A.sbv +++ b/docs/fr/week15/practicum15A.sbv @@ -1068,7 +1068,6 @@ Donc c'est un peu comme s’il dépassait un peu. 0:36:54.160,0:37:03.280 L’énergie libre de cet endroit ici, est de 0,25. 0,5 au carré. - 0:37:03.520,0:37:07.520 Coo, cool, cool. Donc que reste-t-il à vous montrer ? @@ -1097,7 +1096,7 @@ comme ma première localisation. Donc étant donné cette localisation là… prenons du orange… il n’y pas l’orange. Désolé. Prenons du rouge alors. 0:38:10.680,0:38:22.880 -Donc alors disons que j'initialise ma variable latente telle que le g, la version décodée, de z tilde est ce point par ici +Donc alors disons que j'initialise ma variable latente telle que le g, la version décodée, de z̃ est ce point par ici 0:38:22.880,0:38:30.320 Puis nous exécutons notre processus de minimisation pour effectuer une inférence. Pour connaître le z^check. diff --git a/docs/images/week01/01-3/initial_scatter_lab1.png b/docs/images/week01/01-3/initial_scatter_lab1.png index 5defc2349..5349ecf59 100644 Binary files a/docs/images/week01/01-3/initial_scatter_lab1.png and b/docs/images/week01/01-3/initial_scatter_lab1.png differ diff --git a/docs/images/week01/01-3/matrix_multiplication_lab1.png b/docs/images/week01/01-3/matrix_multiplication_lab1.png index 468ec4346..cf95db8b7 100644 Binary files a/docs/images/week01/01-3/matrix_multiplication_lab1.png and b/docs/images/week01/01-3/matrix_multiplication_lab1.png differ diff --git a/docs/images/week01/01-3/matrix_multiplication_lab1_2.png b/docs/images/week01/01-3/matrix_multiplication_lab1_2.png index c09b6ff4c..2001db7de 100644 Binary files a/docs/images/week01/01-3/matrix_multiplication_lab1_2.png and b/docs/images/week01/01-3/matrix_multiplication_lab1_2.png differ diff --git a/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=1_lab1.png b/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=1_lab1.png index 3e1d9a7a3..2007cddb6 100644 Binary files a/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=1_lab1.png and b/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=1_lab1.png differ diff --git a/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=5_lab1.png b/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=5_lab1.png index 7e386a7b8..10482a26a 100644 Binary files a/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=5_lab1.png and b/docs/images/week01/01-3/matrix_multiplication_with_nonlinearity_s=5_lab1.png differ diff --git a/docs/images/week01/01-3/tanh_lab1.png b/docs/images/week01/01-3/tanh_lab1.png index f5facfc3e..929087d3a 100644 Binary files a/docs/images/week01/01-3/tanh_lab1.png and b/docs/images/week01/01-3/tanh_lab1.png differ diff --git a/docs/images/week01/01-3/untrained_nn_transformation_lab1.png b/docs/images/week01/01-3/untrained_nn_transformation_lab1.png index 3192f9d82..e1d451d19 100644 Binary files a/docs/images/week01/01-3/untrained_nn_transformation_lab1.png and b/docs/images/week01/01-3/untrained_nn_transformation_lab1.png differ diff --git a/docs/images/week02/02-1/Average_Loss.png b/docs/images/week02/02-1/Average_Loss.png index df404a2a8..cfbbdf9fa 100644 Binary files a/docs/images/week02/02-1/Average_Loss.png and b/docs/images/week02/02-1/Average_Loss.png differ diff --git a/docs/images/week02/02-1/deterministic_function.png b/docs/images/week02/02-1/deterministic_function.png new file mode 100644 index 000000000..10790fe9d Binary files /dev/null and b/docs/images/week02/02-1/deterministic_function.png differ diff --git a/docs/images/week02/02-1/y.png b/docs/images/week02/02-1/y.png new file mode 100644 index 000000000..a7d025258 Binary files /dev/null and b/docs/images/week02/02-1/y.png differ diff --git a/docs/images/week02/02-2/02-2-1.png b/docs/images/week02/02-2/02-2-1.png index e6b734818..e83dd8395 100644 Binary files a/docs/images/week02/02-2/02-2-1.png and b/docs/images/week02/02-2/02-2-1.png differ diff --git a/docs/images/week02/02-2/02-2-3.png b/docs/images/week02/02-2/02-2-3.png index dd3820879..a9ce2a5c2 100644 Binary files a/docs/images/week02/02-2/02-2-3.png and b/docs/images/week02/02-2/02-2-3.png differ diff --git a/docs/images/week02/02-3/6-nn-confidence.png b/docs/images/week02/02-3/6-nn-confidence.png index e46557d99..fe9f2d610 100644 Binary files a/docs/images/week02/02-3/6-nn-confidence.png and b/docs/images/week02/02-3/6-nn-confidence.png differ diff --git a/docs/images/week02/02-3/clean-spiral.png b/docs/images/week02/02-3/clean-spiral.png index 4bb2a337d..73ccefd83 100644 Binary files a/docs/images/week02/02-3/clean-spiral.png and b/docs/images/week02/02-3/clean-spiral.png differ diff --git a/docs/images/week03/03-1/Gallant_and_Van_Essen.png b/docs/images/week03/03-1/Gallant_and_Van_Essen.png index dff4b7488..2a3b02d53 100644 Binary files a/docs/images/week03/03-1/Gallant_and_Van_Essen.png and b/docs/images/week03/03-1/Gallant_and_Van_Essen.png differ diff --git a/docs/images/week03/03-1/HyperNetwork.png b/docs/images/week03/03-1/HyperNetwork.png index e347d4977..a303e4265 100644 Binary files a/docs/images/week03/03-1/HyperNetwork.png and b/docs/images/week03/03-1/HyperNetwork.png differ diff --git a/docs/images/week03/03-1/PT.png b/docs/images/week03/03-1/PT.png index 4e1de6f9d..98fce4ce7 100644 Binary files a/docs/images/week03/03-1/PT.png and b/docs/images/week03/03-1/PT.png differ diff --git a/docs/images/week03/03-3/Figure 2(a) Before Applying Sparsity.png b/docs/images/week03/03-3/Figure 2(a) Before Applying Sparsity.png index 227633c93..3fa1f47f2 100644 Binary files a/docs/images/week03/03-3/Figure 2(a) Before Applying Sparsity.png and b/docs/images/week03/03-3/Figure 2(a) Before Applying Sparsity.png differ diff --git a/docs/images/week03/03-3/Figure 2(b) After Applying Sparsity.png b/docs/images/week03/03-3/Figure 2(b) After Applying Sparsity.png index 953ab37ac..2acf82751 100644 Binary files a/docs/images/week03/03-3/Figure 2(b) After Applying Sparsity.png and b/docs/images/week03/03-3/Figure 2(b) After Applying Sparsity.png differ diff --git a/docs/images/week06/06-2/LSTM.png b/docs/images/week06/06-2/LSTM.png index e3ab3aef0..c96cdd43e 100644 Binary files a/docs/images/week06/06-2/LSTM.png and b/docs/images/week06/06-2/LSTM.png differ diff --git a/docs/images/week06/06-3/fourth.png b/docs/images/week06/06-3/fourth.png index 55fb49cef..819074a8d 100644 Binary files a/docs/images/week06/06-3/fourth.png and b/docs/images/week06/06-3/fourth.png differ diff --git a/docs/images/week06/06-3/hidden_state_lstm.png b/docs/images/week06/06-3/hidden_state_lstm.png index 366a50225..845b4d291 100644 Binary files a/docs/images/week06/06-3/hidden_state_lstm.png and b/docs/images/week06/06-3/hidden_state_lstm.png differ diff --git a/docs/images/week06/06-3/rnn_2.png b/docs/images/week06/06-3/rnn_2.png index dd3622db7..e6658aacc 100644 Binary files a/docs/images/week06/06-3/rnn_2.png and b/docs/images/week06/06-3/rnn_2.png differ diff --git a/docs/images/week06/06-3/rnn_3.png b/docs/images/week06/06-3/rnn_3.png index e9fd5b1a0..da084f10f 100644 Binary files a/docs/images/week06/06-3/rnn_3.png and b/docs/images/week06/06-3/rnn_3.png differ diff --git a/docs/images/week06/06-3/seq2seq.png b/docs/images/week06/06-3/seq2seq.png index 3f4a2a303..615651976 100644 Binary files a/docs/images/week06/06-3/seq2seq.png and b/docs/images/week06/06-3/seq2seq.png differ diff --git a/docs/images/week06/06-3/seq2vec.png b/docs/images/week06/06-3/seq2vec.png index 032519ea5..df969ffec 100644 Binary files a/docs/images/week06/06-3/seq2vec.png and b/docs/images/week06/06-3/seq2vec.png differ diff --git a/docs/images/week06/06-3/third_2.png b/docs/images/week06/06-3/third_2.png index 12f1ca1d8..eac7a7005 100644 Binary files a/docs/images/week06/06-3/third_2.png and b/docs/images/week06/06-3/third_2.png differ diff --git a/docs/images/week07/07-1/fig3.png b/docs/images/week07/07-1/fig3.png index a6cf68eca..60ab0253b 100644 Binary files a/docs/images/week07/07-1/fig3.png and b/docs/images/week07/07-1/fig3.png differ diff --git a/docs/images/week07/07-1/fig4.png b/docs/images/week07/07-1/fig4.png index 0934bf6a7..3c06e31fa 100644 Binary files a/docs/images/week07/07-1/fig4.png and b/docs/images/week07/07-1/fig4.png differ diff --git a/docs/images/week07/07-2/2_cv_eg.png b/docs/images/week07/07-2/2_cv_eg.png index e33555f89..6022ece9b 100644 Binary files a/docs/images/week07/07-2/2_cv_eg.png and b/docs/images/week07/07-2/2_cv_eg.png differ diff --git a/docs/images/week07/07-2/5_spiral.png b/docs/images/week07/07-2/5_spiral.png index bb21ccb19..6f1e766a7 100644 Binary files a/docs/images/week07/07-2/5_spiral.png and b/docs/images/week07/07-2/5_spiral.png differ diff --git a/docs/images/week07/07-3/10_facepatch.png b/docs/images/week07/07-3/10_facepatch.png new file mode 100644 index 000000000..a52092a8d Binary files /dev/null and b/docs/images/week07/07-3/10_facepatch.png differ diff --git a/docs/images/week07/07-3/11_fixfacepatch.png b/docs/images/week07/07-3/11_fixfacepatch.png new file mode 100644 index 000000000..d0d0a3dbd Binary files /dev/null and b/docs/images/week07/07-3/11_fixfacepatch.png differ diff --git a/docs/images/week07/07-3/16_relation1.png b/docs/images/week07/07-3/16_relation1.png index 3a0b5a782..3d6a7911b 100644 Binary files a/docs/images/week07/07-3/16_relation1.png and b/docs/images/week07/07-3/16_relation1.png differ diff --git a/docs/images/week07/07-3/18_contractive_ae.png b/docs/images/week07/07-3/18_contractive_ae.png index c2979ae39..015e2b1ec 100644 Binary files a/docs/images/week07/07-3/18_contractive_ae.png and b/docs/images/week07/07-3/18_contractive_ae.png differ diff --git a/docs/images/week07/07-3/19_basic_ae.png b/docs/images/week07/07-3/19_basic_ae.png index 4b2e7e6e6..1b004b1c3 100644 Binary files a/docs/images/week07/07-3/19_basic_ae.png and b/docs/images/week07/07-3/19_basic_ae.png differ diff --git a/docs/images/week07/07-3/1_faces_gen.png b/docs/images/week07/07-3/1_faces_gen.png new file mode 100644 index 000000000..4eca7dd1e Binary files /dev/null and b/docs/images/week07/07-3/1_faces_gen.png differ diff --git a/docs/images/week07/07-3/21_output_stae.png b/docs/images/week07/07-3/21_output_stae.png index 2474a3dad..33fcf3cb4 100644 Binary files a/docs/images/week07/07-3/21_output_stae.png and b/docs/images/week07/07-3/21_output_stae.png differ diff --git a/docs/images/week07/07-3/22_out_denoising_ae.png b/docs/images/week07/07-3/22_out_denoising_ae.png index 2a201ea11..217e22508 100644 Binary files a/docs/images/week07/07-3/22_out_denoising_ae.png and b/docs/images/week07/07-3/22_out_denoising_ae.png differ diff --git a/docs/images/week07/07-3/2_bird.png b/docs/images/week07/07-3/2_bird.png new file mode 100644 index 000000000..d140ed3bc Binary files /dev/null and b/docs/images/week07/07-3/2_bird.png differ diff --git a/docs/images/week07/07-3/2_dog.png b/docs/images/week07/07-3/2_dog.png new file mode 100644 index 000000000..f5a641396 Binary files /dev/null and b/docs/images/week07/07-3/2_dog.png differ diff --git a/docs/images/week07/07-3/3_dog2bird.png b/docs/images/week07/07-3/3_dog2bird.png new file mode 100644 index 000000000..f88cdd9b8 Binary files /dev/null and b/docs/images/week07/07-3/3_dog2bird.png differ diff --git a/docs/images/week07/07-3/4_model_d2b.png b/docs/images/week07/07-3/4_model_d2b.png new file mode 100644 index 000000000..fb2c54e4d Binary files /dev/null and b/docs/images/week07/07-3/4_model_d2b.png differ diff --git a/docs/images/week07/07-3/5_zoom1.png b/docs/images/week07/07-3/5_zoom1.png new file mode 100644 index 000000000..a54b801a8 Binary files /dev/null and b/docs/images/week07/07-3/5_zoom1.png differ diff --git a/docs/images/week07/07-3/5_zoom2.png b/docs/images/week07/07-3/5_zoom2.png new file mode 100644 index 000000000..c9f5bc4ac Binary files /dev/null and b/docs/images/week07/07-3/5_zoom2.png differ diff --git a/docs/images/week07/07-3/6_shift1.png b/docs/images/week07/07-3/6_shift1.png new file mode 100644 index 000000000..8044716fa Binary files /dev/null and b/docs/images/week07/07-3/6_shift1.png differ diff --git a/docs/images/week07/07-3/6_shift2.png b/docs/images/week07/07-3/6_shift2.png new file mode 100644 index 000000000..a336d5722 Binary files /dev/null and b/docs/images/week07/07-3/6_shift2.png differ diff --git a/docs/images/week07/07-3/7_bright1.png b/docs/images/week07/07-3/7_bright1.png new file mode 100644 index 000000000..c8b5a7eb2 Binary files /dev/null and b/docs/images/week07/07-3/7_bright1.png differ diff --git a/docs/images/week07/07-3/7_bright2.png b/docs/images/week07/07-3/7_bright2.png new file mode 100644 index 000000000..61b708290 Binary files /dev/null and b/docs/images/week07/07-3/7_bright2.png differ diff --git a/docs/images/week07/07-3/8_rotation1.png b/docs/images/week07/07-3/8_rotation1.png new file mode 100644 index 000000000..2d16f31d0 Binary files /dev/null and b/docs/images/week07/07-3/8_rotation1.png differ diff --git a/docs/images/week07/07-3/8_rotation2.png b/docs/images/week07/07-3/8_rotation2.png new file mode 100644 index 000000000..ac8a3f0e5 Binary files /dev/null and b/docs/images/week07/07-3/8_rotation2.png differ diff --git a/docs/images/week07/07-3/9_reconstruct.png b/docs/images/week07/07-3/9_reconstruct.png new file mode 100644 index 000000000..c4c5009cd Binary files /dev/null and b/docs/images/week07/07-3/9_reconstruct.png differ diff --git a/docs/images/week08/08-1/fig1.png b/docs/images/week08/08-1/fig1.png index ff409cc8d..2beee3cb0 100644 Binary files a/docs/images/week08/08-1/fig1.png and b/docs/images/week08/08-1/fig1.png differ diff --git a/docs/images/week08/08-1/fig2.png b/docs/images/week08/08-1/fig2.png index 50f88e5ab..6b8793988 100644 Binary files a/docs/images/week08/08-1/fig2.png and b/docs/images/week08/08-1/fig2.png differ diff --git a/docs/images/week08/08-3/fig_8.png b/docs/images/week08/08-3/fig_8.png index 8233a894d..41ff21f6e 100644 Binary files a/docs/images/week08/08-3/fig_8.png and b/docs/images/week08/08-3/fig_8.png differ diff --git a/docs/images/week10/10-1/img09.png b/docs/images/week10/10-1/img09.png index 1b035e5e4..50aa2dbbd 100644 Binary files a/docs/images/week10/10-1/img09.png and b/docs/images/week10/10-1/img09.png differ diff --git a/docs/images/week10/10-1/img10.png b/docs/images/week10/10-1/img10.png index 521439dd1..8d21fb912 100644 Binary files a/docs/images/week10/10-1/img10.png and b/docs/images/week10/10-1/img10.png differ diff --git a/docs/images/week10/10-1/img13.png b/docs/images/week10/10-1/img13.png index 29a555a18..417dc691c 100644 Binary files a/docs/images/week10/10-1/img13.png and b/docs/images/week10/10-1/img13.png differ diff --git a/docs/images/week10/10-2/fig07.png b/docs/images/week10/10-2/fig07.png index d0789f108..593e62896 100644 Binary files a/docs/images/week10/10-2/fig07.png and b/docs/images/week10/10-2/fig07.png differ diff --git a/docs/images/week10/10-2/fig08.png b/docs/images/week10/10-2/fig08.png index b4a9edcd6..92a5abb15 100644 Binary files a/docs/images/week10/10-2/fig08.png and b/docs/images/week10/10-2/fig08.png differ diff --git a/docs/images/week10/10-2/fig14.png b/docs/images/week10/10-2/fig14.png index cd24ecc17..e20a521d9 100644 Binary files a/docs/images/week10/10-2/fig14.png and b/docs/images/week10/10-2/fig14.png differ diff --git a/docs/images/week10/10-2/fig15.png b/docs/images/week10/10-2/fig15.png index 1b69b3d40..dbfda0b89 100644 Binary files a/docs/images/week10/10-2/fig15.png and b/docs/images/week10/10-2/fig15.png differ diff --git a/docs/images/week10/10-2/fig17.png b/docs/images/week10/10-2/fig17.png index 1f78434b4..2f44144d1 100644 Binary files a/docs/images/week10/10-2/fig17.png and b/docs/images/week10/10-2/fig17.png differ diff --git a/docs/images/week10/10-2/fig18.png b/docs/images/week10/10-2/fig18.png index 02e22d437..42bec04ae 100644 Binary files a/docs/images/week10/10-2/fig18.png and b/docs/images/week10/10-2/fig18.png differ diff --git a/docs/images/week10/10-2/fig20.png b/docs/images/week10/10-2/fig20.png index 618fe2727..b62cbc9b8 100644 Binary files a/docs/images/week10/10-2/fig20.png and b/docs/images/week10/10-2/fig20.png differ diff --git a/docs/images/week10/10-2/fig23.png b/docs/images/week10/10-2/fig23.png index bfcea97eb..ad9647dff 100644 Binary files a/docs/images/week10/10-2/fig23.png and b/docs/images/week10/10-2/fig23.png differ diff --git a/docs/images/week11/11-3/figure4.png b/docs/images/week11/11-3/figure4.png index 553f8c11c..dfc47589a 100644 Binary files a/docs/images/week11/11-3/figure4.png and b/docs/images/week11/11-3/figure4.png differ diff --git a/docs/images/week11/11-3/figure7.png b/docs/images/week11/11-3/figure7.png index 7ed2a53ce..5b442d45d 100644 Binary files a/docs/images/week11/11-3/figure7.png and b/docs/images/week11/11-3/figure7.png differ diff --git a/docs/images/week11/11-3/figure9.png b/docs/images/week11/11-3/figure9.png index 5631f23e2..7958d55e0 100644 Binary files a/docs/images/week11/11-3/figure9.png and b/docs/images/week11/11-3/figure9.png differ diff --git a/docs/images/week14/14-1/Fig1.png b/docs/images/week14/14-1/Fig1.png index 2cacb30eb..ea20ce95c 100644 Binary files a/docs/images/week14/14-1/Fig1.png and b/docs/images/week14/14-1/Fig1.png differ diff --git a/docs/images/week14/14-1/Fig8.png b/docs/images/week14/14-1/Fig8.png index adc6c318b..ca07dd9de 100644 Binary files a/docs/images/week14/14-1/Fig8.png and b/docs/images/week14/14-1/Fig8.png differ diff --git a/docs/images/week14/14-3/code.jpg b/docs/images/week14/14-3/code.jpg new file mode 100644 index 000000000..38a5790c2 Binary files /dev/null and b/docs/images/week14/14-3/code.jpg differ diff --git a/docs/images/week14/14-3/early_stop.jpg b/docs/images/week14/14-3/early_stop.jpg new file mode 100644 index 000000000..1646fbd9c Binary files /dev/null and b/docs/images/week14/14-3/early_stop.jpg differ diff --git a/docs/images/week14/14-3/network_without_dropout.jpg b/docs/images/week14/14-3/network_without_dropout.jpg new file mode 100644 index 000000000..d3be17f8a Binary files /dev/null and b/docs/images/week14/14-3/network_without_dropout.jpg differ diff --git a/docs/images/week14/14-3/regularization_weights.jpg b/docs/images/week14/14-3/regularization_weights.jpg new file mode 100644 index 000000000..9e4ce0ff3 Binary files /dev/null and b/docs/images/week14/14-3/regularization_weights.jpg differ diff --git a/docs/images/week15/15-2/Figure4.png b/docs/images/week15/15-2/Figure4.png index f5acff743..95310dd08 100644 Binary files a/docs/images/week15/15-2/Figure4.png and b/docs/images/week15/15-2/Figure4.png differ diff --git a/docs/images/week15/15-2/Figure6.png b/docs/images/week15/15-2/Figure6.png index 27abd1b6f..643e5f7e5 100644 Binary files a/docs/images/week15/15-2/Figure6.png and b/docs/images/week15/15-2/Figure6.png differ diff --git a/docs/images/week15/15-2/Figure7.png b/docs/images/week15/15-2/Figure7.png index 408b1adea..847fe043d 100644 Binary files a/docs/images/week15/15-2/Figure7.png and b/docs/images/week15/15-2/Figure7.png differ