Datasets:

lbourdois

/

en-fr-nyu-dl-course-corpus

like 0

Here we define the similarity metric between two feature maps/vectors as the cosine similarity.

Nous définissons ici la métrique de similarité entre deux cartes/vecteurs de caractéristiques comme étant la similarité cosinus.

What PIRL does differently is that it doesn’t use the direct output of the convolutional feature extractor. It instead defines different heads F and g, which can be thought of as independent layers on top of the base convolutional feature extractor.

PIRL n’utilise pas la sortie directe de l’extracteur de caractéristiques du ConvNet. Il définit plutôt différentes têtes F et g, qui peuvent être considérées comme des couches indépendantes au-dessus de l’extracteur de caractéristiques.

In a mini-batch, we will have one positive (similar) pair and many negative (dissimilar) pairs. We then compute the similarity between the transformed image’s feature vector (It) and the rest of the feature vectors in the minibatch (one positive, the rest negative). We then compute the score of a softmax-like function on the positive pair. Maximizing a softmax score means minimizing the rest of the scores, which is exactly what we want for an energy-based model. The final loss function, therefore, allows us to build a model that pushes the energy down on similar pairs while pushing it up on dissimilar pairs.

Dans un mini-batch, nous avons une paire positive (similaire) et de nombreuses paires négatives (dissemblables). Nous calculons ensuite la similarité entre le vecteur caractéristique de l’image transformée (It) et le reste des vecteurs caractéristiques du mini-batch (un positif, le reste négatif). Nous calculons ensuite le score d’une fonction de type softmax sur la paire positive. Maximiser un score softmax signifie minimiser le reste des scores, ce qui est exactement ce que nous voulons pour un modèle à base d’énergie. La fonction de perte finale nous permet donc de construire un modèle qui pousse l’énergie vers le bas sur des paires similaires tout en la poussant vers le haut sur des paires dissemblables.

Dr. LeCun mentions that to make this work, it requires a large number of negative samples. In SGD, it can be difficult to consistently maintain a large number of these negative samples from mini-batches. Therefore, PIRL also uses a cached memory bank.

Yann mentionne que pour que cela fonctionne, il faut un grand nombre d’échantillons négatifs. Dans la 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 mémoire en cache.

Why do we use cosine similarity instead of L2 Norm? With an L2 norm, it’s very easy to make two vectors similar by making them “short” (close to centre) or make two vectors dissimilar by making them very “long” (away from the centre). This is because the L2 norm is just a sum of squared partial differences between the vectors. Thus, using cosine similarity forces the system to find a good solution without “cheating” by making vectors short or long.

Pourquoi utilisons-nous la similarité 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é cosinus oblige le système à trouver une bonne solution sans « tricher » en rendant les vecteurs courts ou longs.

SimCLR

SimCLR

SimCLR shows better results than previous methods. In fact, it reaches the performance of supervised methods on ImageNet, with top-1 linear accuracy on ImageNet. The technique uses a sophisticated data augmentation method to generate similar pairs, and they train for a massive amount of time (with very, very large batch sizes) on TPUs. Dr. LeCun believes that SimCLR, to a certain extent, shows the limit of contrastive methods. There are many, many regions in a high-dimensional space where you need to push up the energy to make sure it’s actually higher than on the data manifold. As you increase the dimension of the representation, you need more and more negative samples to make sure the energy is higher in those places not on the manifold.

SimCLR donne de meilleurs résultats que les méthodes précédentes. En fait, avec un nombre de paramètres suffisants, elle atteint les performances des méthodes supervisées de la « top-1 linear accuracy » sur ImageNet. La technique utilise une méthode sophistiquée d’augmentation de données pour générer des paires similaires et l’entraînement est réalisé pendant un temps considérable (avec des batchs très très importants) sur des TPUs. Yann pense que SimCLR, dans une certaine mesure, montre la limite des méthodes contrastives. Il y a beaucoup beaucoup de régions dans un espace en grande dimension où il faut pousser l’énergie vers le haut pour s’assurer qu’elle est effectivement plus élevée que sur la surface de données. Au fur et à mesure que vous augmentez la dimension de la représentation, vous avez besoin de plus en plus d’échantillons négatifs pour vous assurer que l’énergie est plus élevée dans les endroits qui ne sont pas sur la surface.

Denoising autoencoder

Auto-encodeur débruiteur

In week 7’s practicum, we discussed denoising autoencoder. The model tends to learn the representation of the data by reconstructing corrupted input to the original input. More specifically, we train the system to produce an energy function that grows quadratically as the corrupted data move away from the data manifold.

Dans les travaux dirigés de la semaine 7, nous avons discuté de l’auto-encodeur débruiteur. Le modèle tend à apprendre la représentation des données en reconstruisant l’entrée corrompue à l’entrée originale. Plus précisément, nous entraînons le système à produire une fonction d’énergie qui croît quadratiquement à mesure que les données corrompues s’éloignent de la variétés des données.

Issues

Problèmes

However, there are several problems with denoising autoencoders. One problem is that in a high dimensional continuous space, there are uncountable ways to corrupt a piece of data. So there is no guarantee that we can shape the energy function by simply pushing up on lots of different locations. Another problem with the model is that it performs poorly when dealing with images due to the lack of latent variables. Since there are many ways to reconstruct the images, the system produces various predictions and doesn’t learn particularly good features. Besides, corrupted points in the middle of the manifold could be reconstructed to both sides. This will create flat spots in the energy function and affect the overall performance.

Cependant, l’auto-encodeur débruiteur pose plusieurs problèmes. L’un des problèmes est que dans un espace continu de grande dimension, il existe d’innombrables façons de corrompre une donnée. Il n’y a donc aucune garantie que nous puissions modeler la fonction d’énergie en poussant simplement sur un grand nombre d’endroits différents.

Other Contrastive Methods

Autres méthodes contrastives

There are other contrastive methods such as contrastive divergence, Ratio Matching, Noise Contrastive Estimation, and Minimum Probability Flow. We will briefly discuss the basic idea of contrastive divergence.

Il existe d’autres méthodes contrastives telles que la divergence contrastive, le Ratio Matching, le Noise Contrastive Estimation ou encore le Minimum Probability Flow. Nous abordons brièvement l’idée de base de la divergence contrastive.

Contrastive Divergence

Divergence contrastive

Contrastive divergence (CD) is another model that learns the representation by smartly corrupting the input sample. In a continuous space, we first pick a training sample y and lower its energy. For that sample, we use some sort of gradient-based process to move down on the energy surface with noise. If the input space is discrete, we can instead perturb the training sample randomly to modify the energy. If the energy we get is lower, we keep it. Otherwise, we discard it with some probability. Keep doing so will eventually lower the energy of y. We can then update the parameter of our energy function by comparing y and the contrasted sample yˉ​ with some loss function.

La divergence contrastive est un autre modèle qui apprend la représentation en corrompant intelligemment l’échantillon d’entrée. Dans un espace continu, nous choisissons d’abord un échantillon d’entraînement y et nous en diminuons l’énergie. Pour cet échantillon, nous utilisons une sorte de processus basé sur des gradients pour descendre sur la surface de l’énergie avec du bruit. Si l’espace d’entrée est discret, nous pouvons à la place perturber l’échantillon d’entraînement de manière aléatoire pour modifier l’énergie. Si l’énergie que nous obtenons est plus faible, nous la gardons. Sinon, nous la rejetons avec une certaine probabilité. Si nous continuons ainsi, nous finissons par diminuer l’énergie de y. Nous pouvons alors mettre à jour le paramètre de notre fonction d’énergie en comparant y et l’échantillon contrasté yˉ​ avec une certaine fonction de perte.

Persistent Contrastive Divergence

Divergence contrastive persistante

One of the refinements of contrastive divergence is persistent contrastive divergence. The system uses a bunch of “particles” and remembers their positions. These particles are moved down on the energy surface just like what we did in the regular CD. Eventually, they will find low energy places in our energy surface and will cause them to be pushed up. However, the system does not scale well as the dimensionality increases.

L’un des raffinements de la divergence contrastive est la divergence contrastive persistante. Le système utilise un groupe de « particules » et se souvient de leurs positions. Ces particules sont déplacées vers le bas sur la surface d’énergie, tout comme nous l’avons fait dans la divergence contrastive ordinaire. Finalement, elles trouvent des endroits à faible énergie dans notre surface énergétique et les font monter. Cependant, le système ne s’adapte pas bien à l’échelle car la dimensionnalité augmente.

Regularized Latent Variable Energy Based Models

EBMs à variables latentes régularisées

Regularized latent variable EBMs

EBMs à variables latentes régularisées

Models with latent variables are capable of making a distribution of predictions y‾y​ conditioned on an observed input x and an additional latent variable z. Energy-based models can also contain latent variables:

Les modèles avec des variables latentes sont capables de faire une distribution de prédictions y‾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 :

Unfortunately, if the latent variable z has too much expressive power in producing the final prediction y‾y​, every true output y will be perfectly reconstructed from input x with an appropriately chosen z. This means that the energy function will be 0 everywhere, since the energy is optimized over both y and z during inference.

Malheureusement, si la variable latente z a une trop grande puissance expressive dans la production de la prédiction finale y‾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.

A natural solution is to limit the information capacity of the latent variable z. One way to do this is to regularize the latent variable:

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 :

This method will limit the volume of space of z which takes a small value and the value which will, in turn, controls the space of y that has low energy. The value of λ controls this tradeoff. A useful example of R is the L1​ norm, which can be viewed as an almost everywhere differentiable approximation of effective dimension. Adding noise to z while limiting its L2​ norm can also limit its information content (VAE).

Cette méthode limite le volume de l’espace de z qui prend une petite valeur et la valeur qui, à son tour, contrôle l’espace de y ayant une faible énergie. La valeur de λ contrôle ce compromis. Un exemple utile de R est la norme L1​, qui peut être considérée comme une approximation différenciable de la dimension effective presque partout. Ajouter du bruit à z tout en limitant sa norme L2​ peut également limiter son contenu en information (VAE).

Sparse Coding

Codage épars

Sparse coding is an example of an unconditional regularized latent-variable EBM which essentially attempts to approximate the data with a piecewise linear function.

Le codage épars est un exemple d’EBM à variables latentes régularisées inconditionnelles qui tente essentiellement d’approcher les données avec une fonction linéaire par morceaux :

The n-dimensional vector z will tend to have a maximum number of non-zero components m« nm« n. Then each Wz will be elements in the span of mm columns of W.

Le vecteur z de dimension n a tendance à avoir un nombre maximum de composantes non nulles m« nm« n. Chaque Wz est donc constitué d’éléments dans l’intervalle des mm colonnes de W.

After each optimization step, the matrix W and latent variable z are normalized by the sum of the L2​ norms of the columns of W. This ensures that W and z do not diverge to infinity and zero.

Après chaque étape d’optimisation, la matrice W et la variable latente z sont normalisées par la somme des normes L2​ des colonnes de W. Cela garantit que W et z ne divergent pas à l’infini et à zéro.

FISTA

FISTA

FISTA (fast ISTA) is an algorithm that optimizes the sparse coding energy function E(y,z) with respect to z by alternately optimizing the two terms ∥y−Wz∥2 and λ∥z∥L1​. We initialize Z(0) and iteratively update z according to the following rule:

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 ∥y−Wz∥2 et λ∥z∥L1​. Nous initialisons Z(0) et mettons à jour itérativement z selon la règle suivante :

The inner expression Z(t)−1LWd⊤(WdZ(t)−Y) is a gradient step for the ∥y−Wz∥2 term. The Shrinkagefunction then shifts values towards 0, which optimizes the λ∥z∥L1​​ term.

L’expression interne Z(t)−1LWd⊤(WdZ(t)−Y) est un pas de gradient pour le terme ∥y−Wz∥2. La fonction Shrinkage décale ensuite les valeurs vers 0, ce qui optimise le terme λ∥z∥L1​​.

LISTA

LISTA

FISTA is too expensive to apply to large sets of high-dimensional data (e.g. images). One way to make it more efficient is to instead train a network to predict the optimal latent variable z:

FISTA est trop coûteux pour être appliqué à des jeux de données de grandes dimensions (par exemple les images). Un moyen de le rendre plus efficace est d’entraîner un réseau à prédire la variable latente optimale z :

The energy of this architecture then includes an additional term that measures the difference between the predicted latent variable z‾z and the optimal latent variable z:

L’énergie de cette architecture comprend alors un terme supplémentaire qui mesure la différence entre la variable latente prédite z‾z et la variable latente optimale z :

This update rule can be interpreted as a recurrent network, which suggests that we can instead learn the parameters We​ that iteratively determine the latent variable z. The network is run for a fixed number of time steps k and the gradients of We​ are computed using standard backpropagation-through-time. The trained network then produces a good z in fewer iterations than the FISTA algorithm.

Cette règle de mise à jour peut être interprétée comme un réseau récurrent, ce qui suggère que nous pouvons apprendre les paramètres We​ qui déterminent itérativement la variable latente z. Le réseau est exécuté pour un nombre de pas de temps k fixe et les gradients de We sont calculés en utilisant la rétropropagation standard à travers le temps. Le réseau entraîné produit alors un bon z en moins d’itérations que l’algorithme FISTA.

Sparse coding examples

Exemples de codage épars

When a sparse coding system with 256 dimensional latent vector is applied to MNIST handwritten digits, the system learns a set of 256 strokes that can be linearly combined to nearly reproduce the entire training set. The sparse regularizer ensures that they can be reproduced from a small number of strokes.

Lorsqu’un système de codage épars avec un vecteur latent à 256 dimensions est appliqué aux chiffres manuscrits de MNIST, le système apprend un ensemble de 256 traits qui peuvent être combinés linéairement pour reproduire presque tout l’ensemble d’entraînement. Le régularisateur épars garantit qu’ils peuvent être reproduits à partir d’un petit nombre de traits.

When a sparse coding system is trained on natural image patches, the learned features are Gabor filters, which are oriented edges. These features resemble features learned in early parts of animal visual systems.

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.

Convolutional sparse coding

Codage convolutif épars

Suppose, we have an image and the feature maps (z1,z2,⋯ ,zn​) of the image. Then we can convolve (∗) each of the feature maps with the kernel Ki​. Then the reconstruction can be simply calculated as:

Supposons que nous ayons une image et les cartes de caractéristiques (z1,z2,⋯ ,zn​) de l’image. Nous pouvons faire une convolution (∗) de chacune des cartes de caractéristiques avec le noyau Ki​. La reconstruction peut être alors simplement calculée comme :

This is different from the original sparse coding where the reconstruction was done as Y=∑iWiZi. In regular sparse coding, we have a weighted sum of columns where the weights are coefficients of Zi​. In convolutional sparse coding, it is still a linear operation but the dictionary matrix is now a bunch of feature maps and we convolve each feature map with each kernel and sum up the results.

Cela est différent du codage épars original où la reconstruction est faite sous la forme Y=∑iWiZi​. Dans le codage épars de base, nous avons une somme pondérée de colonnes où les poids sont des coefficients de Zi​. Dans le codage convolutif épars, il s’agit toujours d’une opération linéaire, mais la matrice du dictionnaire est maintenant un ensemble de cartes de caractéristiques et nous effectuons une convolution de chacune d’elles avec chaque noyau et nous additionnons les résultats.

Convolutional sparse auto-encoder on natural images

Auto-encodeur convolutif épars sur des images naturelles

The filters in the encoder and decoder look very similar. Encoder is simply a convolution followed by some non-linearity and then a diagonal layer to change the scale. Then there is sparsity on the constraint of the code. The decoder is just a convolutional linear decoder and the reconstruction here is the square error.

Les filtres de l’encodeur et du décodeur se ressemblent beaucoup. L’encodeur est simplement une convolution suivie d’une non-linéarité, puis une couche diagonale pour changer l’échelle. Ensuite, il y a de l’éparsité sur la contrainte du code. Le décodeur n’est qu’un décodeur linéaire convolutif et la reconstruction est ici l’erreur quadratique.

So, if we impose that there is only one filter then it is just a centre surround type filter. With two filters, we can get some weird shaped filters. With four filters, we get oriented edges (horizontal and vertical); we get 2 polarities for each of the filters. With eight filters we can get oriented edges at 8 different orientations. With 16, we get more orientation along with the centres around. As we go on increasing the filters, we get more diverse filters that is in addition to edge detectors, we also get grating detectors of various orientations, centres around, 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.

This phenomenon seems to be interesting since it is similar to what we observe in the visual cortex. So this is an indication that we can learn really good features in a completely unsupervised way.

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.

As a side use, if we take these features and plug them in a convolutional net and then train them on some task, then we don’t necessarily get better results than training an image net from scratch. However, there are some instances where it can help to boost performance. For instance, in cases where the number of samples are not large enough or there are few categories, by training in a purely supervised manner, we get degenerate features.

Par ailleurs, si nous prenons ces caractéristiques et les connectons à un réseau convolutif, puis que nous les entraînons à une tâche quelconque, nous n’obtenons pas nécessairement de meilleurs résultats qu’un réseau d’images entraîner à partir de zéro. Cependant, dans certains cas, cela peut contribuer à améliorer les performances. Par exemple, dans les cas où le nombre d’échantillons n’est pas assez important ou s’il y a peu de catégories, en entraînant de manière purement supervisée, nous obtenons des caractéristiques dégénérées.

The figure above is another example on colour images. The decoding kernel (on the right side) is of size 9 by 9. This kernel is applied convolutionally over the entire image. The image on the left is of the sparse codes from the encoder. The z vector is very sparse space where there are just few components that are white or black (non-grey).

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).

Variational autoencoder

Auto-encodeurs variationnels

Variational Autoencoders have an architecture similar to Regularized Latent Variable EBM, with the exception of sparsity. Instead, the information content of the code is limited by making it noisy.

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.

The latent variable z is not computed by minimizing the energy function with respect to z. Instead, the energy function is viewed as sampling z randomly according to a distribution whose logarithm is the cost that links it to z‾z. The distribution is a Gaussian with mean z‾z and this results in Gaussian noise being added to z‾z.

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 à z‾z. La distribution est une gaussienne avec une moyenne de z‾z et cela se traduit par l’ajout d’un bruit gaussien à z‾z.

The code vectors with added Gaussian noise can be visualized as fuzy balls as shown in Fig. 9(a).

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).

The system tries to make the code vectors z‾z as large as possible so that the effect of z(noise) is as small as possible. This results in the fuzy balls floating away from the origin as shown in Fig. 9(b). Another reason why the system tries to make the code vectors large is to prevent overlapping fuzy balls, which causes the decoder to confuse between different samples during reconstruction.

Le système essaie de rendre les vecteurs de code z‾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.

But we want the fuzy balls to cluster around a data manifold, if there is one. So, the code vectors are regularized to have a mean and variance close to zero. To do this, we link them to the origin by a spring as shown in Fig. 10.

Mais nous voulons que les boules floues se regroupent autour d’une variété de données, s’il y en a une. Ainsi, les vecteurs de code sont régularisés pour avoir une moyenne et une variance proches de 0. Pour ce faire, nous les relions à l’origine par un ressort comme le montre la figure 10.

The strength of the spring determines how close the fuzy balls are to the origin. If the spring is too weak, then the fuzy balls would fly away from the origin. And if it’s too strong, then they would collapse at the origin, resulting in a high energy value. To prevent this, the system lets the spheres overlap only if the corresponding samples are similar. It is also possible to adapt the size of the fuzy balls. This is limited by a penalty function (KL Divergence) that tries to make the variance close to 1 so that the size of the ball is neither too big nor too small that it collapses.

La force du ressort détermine la proximité des « boules floues » par rapport à l’origine. Si le ressort est trop faible, les boules s’éloignent de l’origine. Et si le ressort est trop fort, alors elles s’effondrent à l’origine, ce qui entraîne 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.

Generative Models - Variational Autoencoders

Modèles Génératifs et Auto-encodeurs variationnels

Recap: Auto-encoder (AE)

Récapitulatif : Auto-encodeur (AE)

To summarize at a high level, a very simple form of AE is as follows:

Pour résumer l’auto-encodeur de manière très simple :

First, the autoencoder takes in an input and maps it to a hidden state through an affine transformation h=f(Wh​x+bh​), where F is an (element-wise) activation function. This is the encoder stage. Note that h is also called the code.

Tout d’abord, l’auto-encodeur prend une entrée et l’associe à un état caché par une transformation affine h=f(Whx+bh), où F est une fonction d’activation (par élément). C’est l’étape de l’encodeur. Notons que h est également appelé le code.

Next, x^=g(Wx​h+bx​), where g is an activation function. This is the decoder stage.

Ensuite, x^=g(Wx​h+bx​), où g est une fonction d’activation. C’est l’étape du décodeur.

For a detailed explaination, refer to the notes of Week 7.

Pour une explication détaillée, voir les notes de la semaine 7.

Intuition behind VAE and a comparison with classic autoencoders

Intuition derrière les VAEs et comparaison avec les auto-encodeurs classiques

Next, we introduce Variational Autoencoders (or VAE), a type of generative models. But why do we even care about generative models? To answer the question, discriminative models learn to make predictions given some observations, but generative models aim to simulate the data generation process. One effect is that generative models can better understand the underlying causal relations which leads to better generalization.

Ensuite, nous présentons les auto-encodeurs variationnels (VAEs), un type de modèles génératifs. Mais pourquoi s’intéresser aux modèles génératifs ? Pour répondre à la question, les modèles discriminants apprennent à faire des prédictions à partir de certaines observations, mais les modèles génératifs visent à simuler le processus de génération de données. Un des effets est que les modèles génératifs peuvent mieux comprendre les relations causales sous-jacentes, ce qui conduit à une meilleure généralisation.

Note that although VAE has “Autoencoders” (AE) in its name (because of structural or architectural similarity to auto-encoders), the formulations between VAEs and AEs are very different. See Figure 1 below.

Il est à noter que bien que le nom VAE contienne le terme « auto-encodeurs » (AE) en raison de la similarité structurelle ou architecturale avec les auto-encodeurs, les formulations entre VAE et AE sont très différentes.

What’s the difference between variational auto-encoder (VAE) and classic auto-encoder (AE)?

Quelle est la différence entre l’auto-encodeur variationnel (VAE) et l’auto-encodeur classique (AE) ?

For VAE:

Pour le VAE :

First, the encoder stage: we pass the input x to the encoder. Instead of generating a hidden representation h (the code) in AE, the code in VAE comprises two things: E(z) and V(z) where z is the latent random variable following a Gaussian distribution with mean E(z) and variance V(z). Note that people use Gaussian distributions as the encoded distribution in practice, but other distributions can be used as well. The encoder will be a function from x to R2d: x↦h (here we use h to represent the concatenation of E(z) and V(z)).

D’abord, l’étape de l’encodeur : nous passons l’entrée x à l’encodeur. Au lieu de générer une représentation cachée h (le code) dans AE, le code dans VAE comprend deux choses : E(z) et V(z) où z est la variable aléatoire latente suivant une distribution gaussienne avec la moyenne E(z) et la variance V(z). A noter qu’en pratique, les gens utilisent les distributions gaussiennes comme distribution encodée, mais d’autres distributions peuvent également être utilisées. L’encodeur sera une fonction de x à R2d : x↦h (ici nous utilisons h pour représenter la concaténation de E(z) et V(z)).

Next, we will sample z from the above distribution parametrized by the encoder; specifically, E(z) and V(z) are passed into a sampler to generate the latent variable z.

Ensuite, nous allons échantillonner z à partir de la distribution ci-dessus paramétrée par l’encodeur. Plus précisément, E(z) et V(z) sont passés dans un échantillonneur pour générer la variable latente z.

Next, z is passed into the decoder to generate x^.

Ensuite, z est passé dans le décodeur pour générer x^.

The decoder will be a function from z to Rn: z↦x^.

Le décodeur sera une fonction de z vers Rn: z↦x^.

In fact, for classic autoencoder, we can think of h as just the vector E(z) in the VAE formulation. In short, the main difference between VAEs and AEs is that VAEs have a good latent space that enables generative process.

En fait, pour l’auto-encodeur classique, on peut considérer h comme le vecteur E(z) de la formulation VAE. En bref, la principale différence entre les VAEs et les AEs est que les VAEs ont un bon espace latent qui permet le processus de génération.

The VAE objective (loss) function

La fonction de perte des VAEs

See Figure 2 above. For now, ignore the top-right corner (which is the reparameterisation trick explained in the next section).

Décrivons cette figure 2 ci-dessus. Commençons par ignorer le coin supérieur droit (qui est l’astuce de reparamétrage expliquée dans la section suivante).

First, we encode from input space (left) to latent space (right), through encoder and noise. Next, we decode from latent space (right) to output space (left). To go from the latent to input space (the generative process) we will need to either learn the distribution (of the latent code) or enforce some structure. In our case, VAE enforces some structure to the latent space.

D’abord nous encodons, de l’espace d’entrée (à gauche) à l’espace latent (à droite), en passant par l’encodeur et le bruit. Ensuite, nous décodons de l’espace latent (à droite) à l’espace de sortie (à gauche). Pour passer de l’espace latent à l’espace d’entrée (le processus de génération), nous devrons soit apprendre la distribution (du code latent), soit appliquer une certaine structure. Dans notre cas, le VAE applique une certaine structure à l’espace latent.

As usual, to train VAE, we minimize a loss function. The loss function is therefore composed of a reconstruction term as well as a regularization term.

Comme d’habitude, pour entraîner le VAE, nous minimisons une fonction de perte. La fonction de perte est donc composée d’un terme de reconstruction ainsi que d’un terme de régularisation.

The reconstruction term is on the final layer (left side of the figure). This corresponds to l(x,x^) in the figure.

Le terme de reconstruction se trouve sur la dernière couche (côté gauche de la figure). Cela correspond à l(x,x^) dans la figure.

The regularization term is on the latent layer, to enforce some specific Gaussian structure on the latent space (right side of the figure). We do so by using a penalty term lKL​(z,N(0,Id​)). Without this term, VAE will act like a classic autoencoder, which may lead to overfitting, and we won’t have the generative properties that we desire.

Le terme de régularisation se trouve sur la couche latente, pour renforcer une structure gaussienne spécifique sur l’espace latent (côté droit de la figure). Pour ce faire, nous utilisons un terme de pénalité lKL(z,N(0,Id)). Sans ce terme, le VAE agira comme un auto-encodeur classique, ce qui peut conduire à du surentraînement et nous n’aurons pas les propriétés génératrices que nous souhaitons.

Discussion on sampling z (reparameterisation trick)

Discussion sur l’échantillonnage z (astuce de paramétrage)

How do we sample from the distribution returned by the encoder in VAE? According to above, we sample from the Gaussian distribution, in order to obtain z. However, this is problematic, because when we do gradient descent to train the VAE model, we don’t know how to do backpropagation through the sampling module.

Comment prélever un échantillon de la distribution renvoyée par l’encodeur dans la VAE ? Selon ce qui précède, nous effectuons un échantillonnage à partir de la distribution gaussienne, afin d’obtenir z. Cependant, cela est problématique, car lorsque nous effectuons une descente de gradient pour entraîner le modèle VAE, nous ne savons pas comment effectuer la rétropropagation par le module d’échantillonnage.

Instead, we use the reparameterization trick to “sample” z. We use z=E(z)+ϵ⊙V(z)

Nous utilisons plutôt l’astuce du reparamétrage pour échantillonner z. Nous utilisons z=E(z)+ϵ⊙V(z)

​ where ϵ∼N(0,Id​). In this case, backpropagation in training is possible. Specifically, the gradients will go through the (element-wise) multiplication and addition in the above equation.

​ où ϵ∼N(0,Id​). Dans ce cas, la rétropropagation lors de l’entraînement est possible. Plus précisément, les gradients passeront par la multiplication (par élément) et l’addition dans l’équation ci-dessus.

Breaking apart the VAE Loss Function

Rompre la fonction de perte des VAEs

Visualizing Latent Variable Estimates and Reconstruction Loss

Visualisation des estimations de variables latentes et de la perte de reconstruction

As stated above, the loss function for the VAE contains two parts: a reconstruction term and a regularization term. We can write this as

Comme indiqué ci-dessus, la fonction de perte pour le VAE comporte deux parties : un terme de reconstruction et un terme de régularisation. On peut écrire cela comme :

To visualize the purpose of each term in the loss function, we can think of each estimated z value as a circle in 2d space, where the centre of the circle is E(z) and the surrounding area are the possible values of z determined by V(z).

Pour visualiser l’objectif de chaque terme dans la fonction de perte, nous pouvons penser à chaque valeur estimée de z comme un cercle dans un espace de 2d, où le centre du cercle est E(z) et la zone environnante sont les valeurs possibles de z déterminées par V(z).

In Figure 3 above, each bubble represents an estimated region of z, and the arrows represent how the reconstruction term pushes each estimated value away from the others, which is explained more below.

Dans la figure 3 ci-dessus, chaque bulle représente une région estimée à z et les flèches représentent comment le terme de reconstruction éloigne chaque valeur estimée des autres, ce qui est expliqué plus en détail ci-dessous.

If there is overlap between any two estimates of z, (visually, if two bubbles overlap) this creates ambiguity for reconstruction because the points in the overlap can be mapped to both original inputs. Therefore the reconstruction loss will push the points away from one another.

S’il y a un chevauchement entre deux estimations de z, (visuellement si deux bulles se chevauchent), cela crée une ambiguïté pour la reconstruction car les points de chevauchement peuvent être mis en correspondance avec les deux entrées originales. Par conséquent, la perte de reconstruction éloignera les points l’un de l’autre.

However, if we use just the reconstruction loss, the estimates will continue to be pushed away from each other and the system could blow up. This is where the penalty term comes in.

Cependant, si nous n’utilisons que la perte de reconstruction, les estimations continueront à être éloignées l’une de l’autre et le système pourrait exploser. C’est là qu’intervient le terme de pénalité.

Note: for binary inputs the reconstruction loss is

Note : pour les entrées binaires, la perte de reconstruction est :

and for real valued inputs the reconstruction loss is

et pour les entrées ayant une valeur réelle, la perte de reconstruction est :

The penalty term

Le terme de pénalité

The second term is the relative entropy (a measure of the distance between two distributions) between z which comes from a Gaussian with mean E(z), variance V(z) and the standard normal distribution. If we expand this second term in the VAE loss function we get:

Le deuxième terme est l’entropie relative (une mesure de la distance entre deux distributions) entre z qui provient d’une gaussienne avec la moyenne E(z), la variance V(z) et la distribution normale standard. Si nous élargissons ce deuxième terme dans la fonction de perte du VAE, nous obtenons

Where each expression in the summation has four terms. Below we write out and graph the first three terms in Figure 4.

Chaque expression de la somme comporte quatre termes. Ci-dessous, nous écrivons les trois premiers termes dans la figure 4 et nous les reportons sur un graphique.

So we can see that this expression is minimized when zi​ has variance 1. Therefore our penalty loss will keep the variance of our estimated latent variables at around 1. Visually, this means our “bubbles” from above will have a radius of around 1.

On peut donc voir que cette expression est minimisée lorsque zi​ a la variance à 1. Par conséquent, notre perte de pénalité maintiendra la variance de nos variables latentes estimées à environ 1. Visuellement, cela signifie que nos « bulles » du haut auront un rayon d’environ 1.

The last term, E(zi)2, minimizes the distance between the zi​ and therefore prevents the “exploding” encouraged by the reconstruction term.

Le dernier terme, E(zi)2, minimise la distance entre les zi​ et empêche donc l’explosion favorisée par le terme de reconstruction.

Figure 5 above shows how VAE loss pushed the estimated latent variables as close together as possible without any overlap while keeping the estimated variance of each point around one.

La figure 5 ci-dessus montre comment la perte du VAE a poussé les variables latentes estimées aussi près que possible l’une de l’autre sans aucun chevauchement tout en maintenant la variance estimée de chaque point autour de 1.

Note: The β in the VAE loss function is a hyperparameter that dictates how to weight the reconstruction and penalty terms.

Note : le β dans la fonction de perte du VAE est un hyperparamètre qui dicte comment pondérer les termes de reconstruction et de pénalité.

The Encoder and the Decoder

L’encodeur et le décodeur

1. We define the encoder and decoder in our VAE module.

1. Nous définissons l’encodeur et le décodeur dans notre module VAE.

2. For the last linear layer of encoder, we define the output to be of size 2d, of which the first d values are the means and the remaining d values are the variances. We sample z∈Rd using these means and variances as explained in the reparameterisation trick before.

2. Pour la dernière couche linéaire de l’encodeur, nous définissons la sortie comme étant de taille 2d, dont les premières valeurs d sont les moyennes et les autres valeurs d sont les variances. Nous échantillonnons z∈Rd en utilisant ces moyennes et variances comme expliqué dans l’astuce de reparamétrage précédente.

3. For the last linear layer in the decoder, we use the sigmoid activation so that we can have output in range [0,1], similar to the input data.

3. Pour la dernière couche linéaire dans le décodeur, nous utilisons l’activation sigmoïde afin de pouvoir avoir une sortie dans la plage [0,1], similaire aux données d’entrée.

Reparameterisation and the forward function

Reparamétrage et fonction forward