Skip to main content

Section 5.5 Auto-encoder et réduction de dimension

Dans cette section on va introduire l'équivalent en apprentissage profond de nos méthodes de réductions précédentes (ISOMAP, Eigenmaps etc).

Subsection 5.5.1 Principe de l'auto-encodeur

Comme précédemment on suppose qu'on a des données \((x_1,..x_n)\) de \(\mathbb{R}^d\) et qu'on peut les approcher de la façon suivante:

\begin{equation*} x= D(z), \mbox{ avec } z \in \mathbb{R}^m \end{equation*}

avec \(m \lt \lt d\) et \(D\) une fonction non linéaire. L'enjeu est donc de trouver les la représentation \(z\) et de trouver l'opérateur \(D\text{.}\) L'idée central des auto-encodeurs est de trouver \(z\) à partir d'une transformation de \(x\) et de construire cette transformation ainsi qu'une approximation de \(D\) en même temps.

Définition 5.62.

Soit \(X\subset \mathbb{R}^d\) et \(Z\subset \mathbf{R}^m\) avec \(m \lt d\text{.}\) On nomme encodeur une fonction paramétrique \(E_{\theta_e}: X \rightarrow Z\) et on nomme décodeur une fonction paramétrique \(D_{\theta_d}: Z \rightarrow X\text{.}\)

Définition 5.63.

Soit \((x_1,..x_n)\) de \(\mathbb{R}^d\text{.}\) On nomme auto-encodeur un couple encodeur-décodeur solution du problème de minimisation:

\begin{equation*} \sum_{i=1}^n\parallel x_i - D_{\theta_d}(E_{\theta_e})(x_i)\parallel_2^2 + R(\theta_e,\theta_d) \end{equation*}

avec \(R\) un terme de régularisation.

L'idée d'un auto-encodeur est donc d'apprendre un opérateur de compression et un opérateur de compression en même temps de façon a ce que la composition des deux soit le plus proche possible de l'identité. Évidemment si \(m\) n'est pas inférieur a \(d\) donc si il n'y pas de perte d'information la solution sera l'identité. Mais dans le cas ou \(m \lt d\) on va avoir de la perte d'information lors de la compression et donc ne pourra pas apprendre l'identité. Dans ce formalisme on peut utiliser n'importe quel modèle paramétrique. On peut montrer qu'en prenant un modèle linéaire pour l'encodeur et le décodeur la solution du problème est donnée par la solution de la PCA. L'idée ici est évidemment d'utiliser des réseaux de neurones pour approcher des transformations nonlinéaires. Les méthodes d'apprentissage de variété calculaient pour les \(x_i\) du jeux l'apprentissage les \(z_i\) et ne fournissait pas d'opérateur \(E\) et \(D\text{.}\) Il fallait compléter cela par la méthode de Neystrom ou une méthode de régression. Ici par construction on définit naturellement les deux opérateurs.

Figure 5.64. Schéma d'un auto-encoder profond.
La forme typique d'un Auto-encodeur basé sur des réseaux MPC est donnée sur la figure Figure 5.64. Les auto-encodeurs basés sur des réseaux MPC ne font pas d'a priori sur la forme des données.

Subsection 5.5.2 Auto-encoder convolutif

Dans le cas de données structurées sur une grille on souhaiterait tirer parti des réseaux convolutifs dans ce genre de cas. Dans ce cas l'idée est d'enchaîner des couches de convolutions avec des couches de pooling (qui diminue la taille du signal). Cependant diminuer la dimension uniquement en divisant par deux la taille du signal peut générer des réseaux assez profonds ou ne pas atteindre une taille cible en dimension réduite. Pour éviter cela au bout d'un certain nombre de blocs: convolution-pooling on applique une couche "flatten" et on enchaîne des couches totalement connectées qui vont aussi baissé la dimension. Le décodeur est construit de façon symétrique. C'est schématisé sur l'image Figure 5.65.

Figure 5.65. Schéma d'un auto-encoder convolutifs profond.
Pour l'objectif de compresser des équations type Burgers les AE couplés aux méthodes du chapitre suivant sont suffisants. Cependant on va introduire des variantes des auto-encodeurs profond qui sont probabilistes.

Subsection 5.5.3 Espace lalent et variantes des AE

Définition 5.66.

Soit des données \(x\in X \subset \mathbb{R}^d\text{.}\) On se donne un encoder et une décodeur tel que

\begin{equation*} E_{\theta_e}(x): X \rightarrow Z\subset \mathbb{R}^m \end{equation*}

et

\begin{equation*} E_{\theta_e}(x): Z \rightarrow X \end{equation*}

L'espace \(Z\) est appelé l'espace latent.

l'espace latent est donc l'espace de petite dimension qui permet de compresser nos données. Comme on l'a déjà introduit précédemment. Il peut être intéressant de construire des modèles de type supervisé directement dans l'espace latent. De plus si on a deux données dans l'espace latent \(z_1\) et \(z_2\) on peut espérer qu’une fois décoder la donnée \(\alpha z_1+(1-\alpha)z_2\) devrait permettre de générer une nouvelle donnée en grande dimension ressemblante aux précédentes. (ref image)

Des méthodes de compression linéaires comme l'ACP génèrent des espaces latents avec des propriétés intéressantes. Les vecteurs de bases dans l'espace réduit sont orthogonales. De plus les vecteurs de bases sont ordonnés en fonction de leurs capacités de représentation (on peut interpréter cela comme une base spectrale ou plus on ajoute des modes plus on ajoute des détails associés aux hautes fréquences). Puisque les auto-encodeurs sont des méthodes nonlinéaires, elles permettent une meilleure compression que les méthodes linéaires comme l'ACP. Mais l'espace latent est plus difficile interprétable (on ne connaît pas les variables dominantes) et on ne peut pas exclure que certaines variables soient corrélées entre elles.

Une première approche pour introduire de la structure dans l'espace latent a été d'introduire de la parcimonie dans la représentation latente. On parle d'autoencodeur parcimonieux.

Définition 5.67. Autoencodeur k-parcimonieux.

Un auto-encodeur \(k\) parcimonieux est un auto-encodeur ou on modifie la dernière couche de l'encodeur. Si l'avant-dernière couche génère une donnée à de dimension \(m\text{:}\) \(x=(x_1,...,x_m)\) on ajoute comme fonction d'activation de cette couche:

\begin{equation*} \sigma(x)=(x_1 b_1,....,x_m b_m) \end{equation*}

avec \(b_i=1\) si \(\mid x_i\mid\) est un des k plus grands module et \(b_i=0\) sinon.

On peut donner une version relaxée de ce type d'auto-encodeur. On va imposer faiblement la parcimonie dans chaque couche. Pour cela on va ajouter une régularisation dans la fonction coût pour essayer d'obtenir cela.

Définition 5.68. Régularisation parcimonieuse I.

Un auto-encodeur parcimonieux à \(K\) couche utilise la fonction de coût Définition 5.63 avec la régularisation suivante:

\begin{equation*} R(\theta_e,\theta_a)=\sum_{k\in (1,K)}\sum_{i=1^N} w_k r(\hat{\rho}_k,\rho_k(x_i)) \end{equation*}

avec \(w_k\) des poids, \(s\) une fonction comme \(r(x,y)=\mid x-y \mid^p\) avec \(\rho_k(x)\) un indicateur de la parcimonie de la couche \(k\) définie par

\begin{equation*} \rho_k(x)=\frac{1}{m}\sum_{i=1}^m \sigma_{k,j}(x) \end{equation*}

avec \(\sigma_{k,j}\) la fonction d'activation de la couche \(k\) et du neurone \(j\text{.}\) La quantité \(\hat{\rho}_k\) correspond à la parcimonie visée pour une couche donnée.

Définition 5.69. Régularisation parcimonieuse II.

Un auto-encodeur parcimonieux à \(K\) couche utilise la fonction de coût Définition 5.63 avec la régularisation suivante:

\begin{equation*} R(\theta_e,\theta_a)=\sum_{k\in (1,K)}\sum_{i=1^N} w_k \parallel h_k\parallel_1 \end{equation*}

avec \(h_k\) le vecteur issu de la couche \(k\text{.}\)

Une autre possibilité pour ajouter un peu de robustesse est d'utiliser ce qu'on appelle des auto-encodeurs contractant. Il s'agit de forcer l'encodeur à être une application la plus contractante possible. Pour cela on va donc minimiser la jacobienne. Cela revient a imposer qu'une faible fluctuation de l'entrée entraîne une faible fluctuation de la représentation latente.

Définition 5.70. Régularisation contractante.

Un auto-encodeur contractante utilise la fonction de coût Définition 5.63 avec la régularisation suivante:

\begin{equation*} R(\theta_e,\theta_a)=\sum_{i=1^N} \parallel \nabla_{\theta_e} E_{\theta_e}(x)\parallel_F^2 \end{equation*}

avec \(\parallel.\parallel_F^2\) la norme de Frobinus.

Afin d'obtenir un espace latent avec des propriétés vraiment proche de l'ACP (variables peu corrélée et ordonnable) il est proposé dans (ref) un algorithme combinant ACP et AE.

Subsubsection 5.5.3.1 Auto-encodeur ACP

L'idée de cette approche va être de construire l'espace latent en augmentant progressivement la taille de celui-ci et en minimisation les corrélations entre les variables latentes. On se fixe une famille d'auto-encoder \(E_{\theta_k}(x)\) de poids \(\theta_k\text{.}\) Si on se donne un jeu de données \((x_1,....x_n)\in \mathbb{R}^n\) notre objectif est de construire les variables latentes: \((z_1,....z_n)\in \mathbb{R}^d\text{.}\)

Définition 5.71.

Si on se donne deux composantes d'une données latente \(z_i\) noté \(z_i^1\) et \(z_i^2\) la covariance entre ses deux composantes associées aux jeux de données est définie par

\begin{equation*} \frac{1}{n}\left( \sum_{i=1}^n z_i^1 z_i^2\right)-\frac{1}{n} \left( \sum_{i=1}^n z_i^1\right) \left( \sum_{i=1}^n z_i^2\right) \end{equation*}

Si les données sont de moyenne nulle ce la revient à

\begin{equation*} \frac{1}{n} \left( \sum_{i=1}^n z_i^1\right) \left( \sum_{i=1}^n z_i^2\right) \end{equation*}
Obtenir des données de moyennes nulles peut être effectué en ajoutant une couche de normalisation par mini lot. Ensuite on va entraîner les auto-encodeur un par un en fixant a chaque fois le précédent et en minimisant la covariance entre les composantes.
Définition 5.72. Auto-encodeur ACP.

Un auto-encodeur ACP est constitué d'une série d'encodeurs \(E_{\theta_1},....,E_{\theta_K}\) et d'un décodeur \(D\text{.}\) On entraîne les encodeurs un par un et on réentraîne le décodeur à chaque fois. Pour cela on minimise à l'itération \(k\text{:}\)

\begin{equation*} \mathcal{L}^k(x)=\sum_{i=1}^n \parallel x_i - D_{\theta_d} (E_{\theta_k}(x_i))\parallel_2^2 +\lambda R(\theta_k) \end{equation*}

avec

\begin{equation*} R(\theta_k)= \frac{1}{k}\sum_{j=1}^k\left(\frac{1}{n}\left( \sum_{i=1}^n z_i^1\right) \left( \sum_{i=1}^n z_i^2\right)\right) \end{equation*}
Avec ce type d'approche, on espère avec un espace latent plus structuré.