Semi-Supervised Learning with Ladder Networks

Introduction

In this paper, we introduce an unsupervised learning method that fits well with supervised learning. The idea of using unsupervised learning to complement supervision is not new. Combining an auxiliary task to help train a neural network was proposed by Suddarth and Kergosien (1990). By sharing the hidden representations among more than one task, the network generalizes better. There are multiple choices for the unsupervised task, for example, reconstruction of the inputs at every level of the model (e.g., Ranzato and Szummer, 2008) or classification of each input sample into its own class (Dosovitskiy et al., 2014).

Although some methods have been able to simultaneously apply both supervised and unsupervised learning (Ranzato and Szummer, 2008; Goodfellow et al., 2013a), often these unsupervised auxiliary tasks are only applied as pre-training, followed by normal supervised learning (e.g., Hinton and Salakhutdinov, 2006). In complex tasks there is often much more structure in the inputs than can be represented, and unsupervised learning cannot, by definition, know what will be useful for the task at hand. Consider, for instance, the autoencoder approach applied to natural images: an auxiliary decoder network tries to reconstruct the original input from the internal representation. The autoencoder will try to preserve all the details needed for reconstructing the image at pixel level, even though classification is typically invariant to all kinds of transformations which do not preserve pixel values. Most of the information required for pixel-level reconstruction is irrelevant and takes space from the more relevant invariant features which, almost by definition, cannot alone be used for reconstruction.

Our approach follows Valpola (2015), who proposed a Ladder network where the auxiliary task is to denoise representations at every level of the model. The model structure is an autoencoder with skip connections from the encoder to decoder and the learning task is similar to that in denoising autoencoders but applied to every layer, not just the inputs. The skip connections relieve the pressure to represent details in the higher layers of the model because, through the skip connections, the decoder can recover any details discarded by the encoder. Previously, the Ladder network has only been demonstrated in unsupervised learning (Valpola, 2015; Rasmus et al., 2015a) but we now combine it with supervised learning.

The key aspects of the approach are as follows:

Compatibility with supervised methods. The unsupervised part focuses on relevant details found by supervised learning. Furthermore, it can be added to existing feedforward neural networks, for example multi-layer perceptrons (MLPs) or convolutional neural networks (CNNs) (Section 3). We show that we can take a state-of-the-art supervised learning method as a starting point and improve the network further by adding simultaneous unsupervised learning (Section 4).

Scalability resulting from local learning. In addition to a supervised learning target on the top layer, the model has local unsupervised learning targets on every layer, making it suitable for very deep neural networks. We demonstrate this with two deep supervised network architectures.

Computational efficiency. The encoder part of the model corresponds to normal supervised learning. Adding a decoder, as proposed in this paper, approximately triples the computation during training but not necessarily the training time since the same result can be achieved faster through the better utilization of the available information. Overall, computation per update scales similarly to whichever supervised learning approach is used, with a small multiplicative factor.

As explained in Section 2, the skip connections and layer-wise unsupervised targets effectively turn autoencoders into hierarchical latent variable models which are known to be well suited for semi-supervised learning. Indeed, we obtain state-of-the-art results in semi-supervised learning in the MNIST, permutation invariant MNIST and CIFAR-10 classification tasks (Section 4). However, the improvements are not limited to semi-supervised settings: for the permutation invariant MNIST task, we also achieve a new record with the normal full-labeled setting.Preliminary results on the full-labeled setting on a permutation invariant MNIST task were reported in a short early version of this paper (Rasmus et al., 2015b). Compared to that, we have added noise to all layers of the model and further simplified the denoising function $g$. This further improved the results.

Derivation and justification

Latent variable models are an attractive approach to semi-supervised learning because they can combine supervised and unsupervised learning in a principled way. The only difference is whether the class labels are observed or not. This approach was taken, for instance, by Goodfellow et al. (2013a) with their multi-prediction deep Boltzmann machine. A particularly attractive property of hierarchical latent variable models is that they can, in general, leave the details for the lower levels to represent, allowing higher levels to focus on more invariant, abstract features that turn out to be relevant for the task at hand.

The training process of latent variable models can typically be split into inference and learning, that is, finding the posterior probability of the unobserved latent variables and then updating the underlying probability model to fit the observations better. For instance, in the expectation-maximization (EM) algorithm, the E-step corresponds to finding the expectation of the latent variables over the posterior distribution assuming the model fixed and the M-step then maximizes the underlying probability model assuming the expectation fixed.

The main problem with latent variable models is how to make inference and learning efficient. Suppose there are layers $l$ of latent variables $\mathbf{z}^{(l)}$. Latent variable models often represent the probability distribution of all the variables explicitly as a product of terms, such as $p(\mathbf{z}^{(l)}\mid\mathbf{z}^{(l+1)})$ in directed graphical models. The inference process and model updates are then derived from Bayes’ rule, typically as some kind of approximation. The inference is often iterative as it is generally impossible to solve the resulting equations in a closed form as a function of the observed variables.

While dAEs are normally only trained to denoise the observations, the DSS framework is based on the idea of using denoising functions $\hat{\mathbf{z}}=g(\mathbf{z})$ of the latent variables $\mathbf{z}$ to train a mapping $\mathbf{z}=f(\mathbf{x})$ which models the likelihood of the latent variables as a function of the observations. The cost function is identical to that used in a dAE except that the latent variables $\mathbf{z}$ replace the observations $\mathbf{x}$; that is, the cost is $\|\hat{\mathbf{z}}-\mathbf{z}\|^{2}$. The only thing to keep in mind is that $\mathbf{z}$ needs to be normalized somehow as otherwise the model has a trivial solution at $\mathbf{z}=\hat{\mathbf{z}}=$ constant. In a dAE, this cannot happen as the model cannot change the input $\mathbf{x}$.

One way to picture the Ladder network is to consider it as a collection of nested denoising autoencoders which share parts of the denoising machinery with each other. From the viewpoint of the autoencoder on layer $l$, the representations on the higher layers can be treated as hidden neurons. In other words, there is no particular reason why $\hat{\mathbf{z}}^{(l+i)}$ as produced by the decoder should resemble the corresponding representations $\mathbf{z}^{(l+i)}$ as produced by the encoder. It is only the cost function $C^{(l+i)}_{d}$ that ties these together and forces the inference to proceed in reverse order in the decoder. This sharing helps a deep denoising autoencoder to learn the denoising process as it splits the task into meaningful sub-tasks of denoising intermediate representations.

Implementation of the Model

The steps involved in implementing the Ladder network (Section 3.1) are typically as follows: 1) take a feedforward model which serves supervised learning as the encoder (Section 3.2); 2) add a decoder which can invert the mappings on each layer of the encoder and supports unsupervised learning (Section 3.3); and 3) train the whole Ladder network by minimizing the sum of all the cost function terms.

In this section, we will go through these steps in detail for a fully connected MLP network and briefly outline the modifications required for convolutional networks, both of which are used in our experiments (Section 4).

Consider training a classifier,Here we only consider the case where the output $t(n)$ is a class label but it is trivial to apply the same approach to other regression tasks., or a mapping from input $\mathbf{x}$ to output $y$ with targets $t$, from a training set of pairs $\{\mathbf{x}(n),t(n)\mid 1\leq n\leq N\}$. Semi-supervised learning (Chapelle et al., 2006) studies how auxiliary unlabeled data $\{\mathbf{x}(n)\mid N+1\leq n\leq M\}$ can help in training a classifier. It is often the case that labeled data are scarce whereas unlabeled data are plentiful, that is $N\ll M$.

The Ladder network can improve results even without auxiliary unlabeled data but the original motivation was to make it possible to take well-performing feedforward classifiers and augment them with an auxiliary decoder as follows:

Train any standard feedforward neural network. The network type is not limited to standard MLPs, but the approach can be applied, for example, to convolutional or recurrent networks. This will be the encoder part of the Ladder network.

For each layer, analyze the conditional distribution of representations given the layer above, $p(\mathbf{z}^{(l)}\mid\mathbf{z}^{(l+1)})$. The observed distributions could resemble for example Gaussian distributions where the mean and variance depend on the values $\mathbf{z}^{(l+1)}$, bimodal distributions where the relative probability masses of the modes depend on the values $\mathbf{z}^{(l+1)}$, and so on.

Train the whole network in a fully-labeled or semi-supervised setting using standard optimization techniques such as stochastic gradient descent.

2 Fully Connected MLP as Encoder

As a starting point we use a fully connected MLP network with rectified linear units. We follow Ioffe and Szegedy (2015) and apply batch normalization to each preactivation including the topmost layer in the $L$-layer network. This serves two purposes. First, it improves convergence as a result of reduced covariate shift as originally proposed by Ioffe and Szegedy (2015). Second, as explained in Section 2, DSS-type cost functions for all but the input layer require some type of normalization to prevent the denoising cost from encouraging the trivial solution where the encoder outputs just constant values as these are the easiest to denoise. Batch normalization conveniently serves this purpose, too.

Formally, batch normalization for the layers $l=1\dots L$ is implemented as

In other words, we also use the noise to regularize supervised learning.

We saw networks with this structure reach close to state-of-the-art results in purely supervised learning (see e.g. Table 1), which makes them good starting points for improvement via semi-supervised learning by adding an auxiliary unsupervised task.

3 Decoder for Unsupervised Learning

When designing a suitable decoder to support unsupervised learning, we had to make a choice as to what kinds of distributions of the latent variables the decoder would optimally be able to denoise. We ultimately ended up choosing a parametrization that supports the optimal denoising of Gaussian latent variables. We also experimented with alternative denoising functions, more details of which can be found in Appendix B. Further analysis of different denoising functions was recently published by Pezeshki et al. (2015).

The denoising function will therefore have the form:

We relax this assumption by making the model only require the distribution of $z$ of a layer to be Gaussian conditional on the values of the latent variables of the layer above. In a similar vein, in a layer of multiple latent variables we can assume that the latent variables are independent conditional on the latent variables of the layer above. The distribution of the latent variables $\mathbf{z}^{(l)}$ is therefore assumed to follow the distribution

where $p(z_{i}^{(l)}\mid\mathbf{z}^{(l+1)})$ are conditionally independent Gaussian distributions.

One interpretation of this formulation is that we are modeling the distribution of $\mathbf{z}^{(l)}$ as a mixture of Gaussians with diagonal covariance matrices, where the value of the above layer $\mathbf{z}^{(l+1)}$ modulates the form of the Gaussian that $\mathbf{z}^{(l)}$ is distributed as. In practice, we will implement the dependence of $\mathbf{v}$ and $\boldsymbol{\mu}$ on $\hat{\mathbf{z}}^{(l+1)}$ with a batch normalized projection from $\hat{\mathbf{z}}^{(l+1)}$ followed by an expressive nonlinearity with trainable parameters. The final formulation of the denoising function is therefore

where $u_{i}^{(l)}$ propagates information from $\hat{\mathbf{z}}^{(l+1)}$ by a batch normalized projection:

where the matrix $\mathbf{V}^{(l)}$ has the same dimension as the transpose of $\mathbf{W}^{(l)}$ on the encoder side. The projection vector $\mathbf{u}^{(l)}$ therefore has the same dimensionality as $\mathbf{z}^{(l)}$. Furthermore, the functions $\mu_{i}(u_{i}^{(l)})$ and $\upsilon_{i}(u_{i}^{(l)})$ are modeled as expressive nonlinearities:

As a side note, if the values of $\mathbf{z}^{(l)}$ are truly independently distributed Gaussians, there is nothing left for the layer above, $\hat{\mathbf{z}}^{(l+1)}$, to model. In that case, a mixture of Gaussians is not needed to model $\mathbf{z}^{(l)}$, but a diagonal Gaussian which can be modeled with a linear denoising function with constant values for $\boldsymbol{\upsilon}$ and $\mu$ as in Equation 1, would suffice. In this parametrization all correlations, nonlinearities, and non-Gaussianities in the latent variables $\mathbf{z}^{(l)}$ have to be represented by modulations from the layers above for optimal denoising. As the parametrization allows the distribution of $\mathbf{z}^{(l)}$ to be modulated by $\mathbf{z}^{(l+1)}$ through $\mathbf{u}^{(l)}$, it encourages the decoder to find representations $\mathbf{z}^{(l)}$ that have high mutual information with $\mathbf{z}^{(l+1)}$. This is crucial as it allows supervised learning to have an indirect influence on the representations learned by the unsupervised decoder: any abstractions selected by supervised learning will bias the lower levels to find more representations which carry information about the same abstractions.

where $m_{l}$ is the layer’s width, N the number of training samples, and the hyperparameter $\lambda_{l}$ a layer-wise multiplier determining the importance of the denoising cost.

4 Variations

Section 3.3 detailed how to build a decoder for the Ladder network to match the fully connected encoder described in Section 3.2. It is easy to extend the same approach to other encoders, for instance, convolutional neural networks (CNN). For the decoder of fully connected networks we used vertical mappings whose shape is a transpose of the encoder mapping. The same treatment works for the convolution operations: in the networks we have tested in this paper, the decoder has convolutions whose parametrization mirrors the encoder and effectively just reverses the flow of information. As the idea of convolution is to reduce the number of parameters by weight sharing, we applied this to the parameters of the denoising function g, too.

Many convolutional networks use pooling operations with stride; that is, they downsample the spatial feature maps. The decoder needs to compensate for this with a corresponding upsampling. There are several alternative ways to implement this and in this paper we chose the following options: 1) on the encoder side, pooling operations are treated as separate layers with their own batch normalization and linear activation function, and 2) the downsampling of the pooling on the encoder side is compensated for by upsampling with copying on the decoder side. This provides multiple targets for the decoder to match, helping the decoder to recover the information lost on the encoder side.

It is worth noting that a simple special case of the decoder is a model where $\lambda_{l}=0$ when $l<L$. This corresponds to a denoising cost only on the top layer and means that most of the decoder can be omitted. This model, which we call the $\Gamma$-model because of the shape of the graph, is useful as it can easily be plugged into any feedforward network without decoder implementation. In addition, the $\Gamma$-model is the same for MLPs and convolutional neural networks. The encoder in the $\Gamma$-model still includes both the clean and the corrupted paths as in the full ladder.

Experiments

With the experiments with the MNIST and CIFAR-10 datasets, we wanted to compare our method to other semi-supervised methods but also show that we can attach the decoder both to a fully connected MLP network and to a convolutional neural network, both of which were described in Section 3. We also wanted to compare the performance of the simpler $\Gamma$-model (Sec. 3.4) to the full Ladder network and experimented with only having a cost function on the input layer. With CIFAR-10, we only tested the $\Gamma$-model.

We also measured the performance of the supervised baseline models which only included the encoder and the supervised cost function. In all cases where we compared these directly with Ladder networks, we did our best to optimize the hyperparameters and regularization of the baseline supervised learning models so that any improvements could not be explained, for example, by the lack of suitable regularization which would then have been provided by the denoising costs.

With convolutional networks, our focus was exclusively on semi-supervised learning. The supervised baselines for all labels only intend to show that the performance of the selected network architectures is in line with the ones reported in the literature. We make claims neither about the optimality nor the statistical significance of these baseline results.

We used the Adam optimization algorithm (Kingma and Ba, 2015) for the weight updates. The learning rate was 0.002 for the first part of the learning, followed by an annealing phase during which the learning rate was linearly reduced to zero. The minibatch size was 100. The source code for all the experiments is available at https://github.com/arasmus/ladder unless explicitly noted in the text.

For evaluating semi-supervised learning, we used the standard 10,000 test samples as a held-out test set and randomly split the standard 60,000 training samples into a 10,000-sample validation set and used $M=50,000$ samples as the training set. From the training set, we randomly chose $N=100$, $1000$, or all labels for the supervised cost.In all the experiments, we were careful not to optimize any parameters, hyperparameters, or model choices on the basis of the results on the held-out test samples. As is customary, we used 10,000 labeled validation samples even for those settings where we only used 100 labeled samples for training. Obviously, this is not something that could be done in a real case with just 100 labeled samples. However, MNIST classification is such an easy task, even in the permutation invariant case, that 100 labeled samples there correspond to a far greater number of labeled samples in many other datasets. All the samples were used for the decoder, which does not need the labels. The validation set was used for evaluating the model structure and hyperparameters. We also balanced the classes to ensure that no particular class was over-represented. We repeated each training 10 times, varying the random seed that was used for the splits.

After optimizing the hyperparameters, we performed the final test runs using all the $M=60,000$ training samples with 10 different random initializations of the weight matrices and data splits. We trained all the models for 100 epochs followed by 50 epochs of annealing. With minibatch size of 100, this amounts to 75,000 weight updates for the validation runs and 90,000 for the final test runs.

A useful test for general learning algorithms is the permutation invariant MNIST classification task. Permutation invariance means that the results need to be invariant with respect to permutation of the elements of the input vector. In other words, one is not allowed to use prior information about the spatial arrangement of the input pixels. This excludes, among others, convolutional networks and geometric distortions of the input images.

We chose the layer sizes of the baseline model to be 784-1000-500-250-250-250-10. The network is deep enough to demonstrate the scalability of the method but does not yet represent overkill for MNIST.

The hyperparameters we tuned for each model are the noise level that is added to the inputs and to each layer, and the denoising cost multipliers $\lambda^{(l)}$. We also ran the supervised baseline model with various noise levels. For models with just one cost multiplier, we optimized them with a search grid $\{\ldots$, 0.1, 0.2, 0.5, 1, 2, 5, 10, $\ldots$}. Ladder networks with a cost function on all their layers have a much larger search space and we explored it much more sparsely. For instance, the optimal model we found for $N=100$ labels had $\lambda^{(0)}=1000$, $\lambda^{(1)}=10$, and $\lambda^{(\geq 2)}=0.1$. A good value for the std of the Gaussian corruption noise $\mathbf{n}^{(l)}$ was mostly $0.3$ but with $N=1000$ labels, $0.2$ was a better value. For the complete set of selected denoising cost multipliers and other hyperparameters, please refer to the code.

The results presented in Table 1 show that the proposed method outperforms all the previously reported results. Encouraged by the good results, we also tested with $N=50$ labels and got a test error of 1.62 % ($\pm$ 0.65 %).

The simple $\Gamma$-model also performed surprisingly well, particularly for $N=1000$ labels. With $N=100$ labels, all the models sometimes failed to converge properly. With bottom level or full costs in Ladder, around 5 % of runs result in a test error of over 2 %. In order to be able to estimate the average test error reliably in the presence of such random outliers, we ran 40 instead of 10 test runs with random initializations.

1.2 Convolutional networks

We tested two convolutional networks for the general MNIST classification task but omitted data augmentation such as geometric distortions. We focused on the 100-label case since with more labels the results were already so good even in the more difficult permutation invariant task.

The first network was a straightforward extension of the fully connected network tested in the permutation invariant case. We turned the first fully connected layer into a convolution with 26-by-26 filters, resulting in a 3-by-3 spatial map of 1000 features. Each of the nine spatial locations was processed independently by a network with the same structure as in the previous section, finally resulting in a 3-by-3 spatial map of 10 features. These were pooled with a global mean-pooling layer. Essentially we thus convolved the image with the complete fully connected network. Depooling on the topmost layer and deconvolutions on the layers below were implemented as described in Section 3.4. Since the internal structure of each of the nine almost independent processing paths was the same as in the permutation invariant task, we used the same hyperparameters that were optimal for the permutation invariant task. In Table 2, this model is referred to as Conv-FC.

With the second network, which was inspired by ConvPool-CNN-C from Springenberg et al. (2014), we only tested the $\Gamma$-model. The MNIST classification task can typically be solved with a smaller number of parameters than CIFAR-10, for which this topology was originally developed, so we modified the network by removing layers and reducing the number of parameters in the remaining layers. In addition, we observed that adding a small fully connected layer with 10 neurons on top of the global mean pooling layer improved the results in the semi-supervised task. We did not tune other parameters than the noise level, which was chosen from $\{0.3,0.45,0.6\}$ using the validation set. The exact architecture of this network is detailed in Table 4 in Appendix A. It is referred to as Conv-Small since it is a smaller version of the network used forthe CIFAR-10 dataset.

The results in Table 2 confirm that even the single convolution on the bottom level improves the results over the fully connected network. More convolutions improve the $\Gamma$-model significantly, although the high variance of the results suggests that the model still suffers from confirmation bias. The Ladder network with denoising targets on every level converges much more reliably. Taken together, these results suggest that combining the generalization ability of convolutional networksIn general, convolutional networks excel in the MNIST classification task. The performance of the fully supervised Conv-Small with all labels is in line with the literature and is provided as a rough reference only (only one run, no attempts to optimize, not available in the code package). and efficient unsupervised learning of the full Ladder network would have resulted in even better performance but this was left for future work.

2 Convolutional networks on CIFAR-10

The CIFAR-10 dataset consists of small 32-by-32 RGB images from 10 classes. There are 50,000 labeled samples for training and 10,000 for testing. Like the MNIST dataset, it has been used for testing semi-supervised learning so we decided to test the simple $\Gamma$-model with a convolutional network that has been reported to perform well in the standard supervised setting with all labels. We tested a few model architectures and selected ConvPool-CNN-C by Springenberg et al. (2014). We also evaluated the strided convolutional version by Springenberg et al. (2014), and while it performed well with all labels, we found that the max-pooling version overfitted less with fewer labels, and thus used it.

The main differences to ConvPool-CNN-C are the use of Gaussian noise instead of dropout and the convolutional per-channel batch normalization following Ioffe and Szegedy (2015). While dropout was useful with all labels, it did not seem to offer any advantage over additive Gaussian noise with fewer labels. For a more detailed description of the model, please refer to model Conv-Large in Table 4.

While testing the purely supervised model performance with a limited number of labeled samples ($N=4000$), we found out that the model overfitted quite severely: the training error for most samples decreased so much that the network effectively learned nothing from them as the network was already very confident about their classification. The network was equally confident about validation samples even when they were misclassified. We noticed that we could regularize the network by stripping away the scaling parameter $\boldsymbol{\beta}^{(L)}$ from the last layer. This means that the variance of the input to the softmax is restricted to unity. We also used this setting with the corresponding $\Gamma$-model although the denoising target already regularizes the network significantly and the improvement was not as pronounced.

The hyperparameters (noise level, denoising cost multipliers, and number of epochs) for all models were optimized using $M=40,000$ samples for training and the remaining $10,000$ samples for validation. After the best hyperparameters were selected, the final model was trained with these settings on all the $M=50,000$ samples. All experiments were run with with four different random initializations of the weight matrices and data splits. We applied global contrast normalization and whitening following Goodfellow et al. (2013b), but no data augmentation was used.

The results are shown in Table 3. The supervised reference was obtained with a model closer to the original ConvPool-CNN-C in the sense that dropout rather than additive Gaussian noise was used for regularization.Same caveats hold for this fully supervised reference result for all labels as with MNIST: only one run, no attempts to optimize, not available in the code package. We spent some time tuning the regularization of our fully supervised baseline model for $N=4000$ labels and indeed, its results exceed the previous state of the art. This tuning was important to make sure that the improvement offered by the denoising target of the $\Gamma$-model is not a sign of a poorly regularized baseline model. Although the improvement is not as dramatic as with the MNIST experiments, it came with a very simple addition to standard supervised training.

Related Work

It is well known (see, e.g., Zhang and Oles, 2000) that when a probabilistic model that directly estimates $P(y\mid\mathbf{x})$ is being trained, unlabeled data cannot help. One way to study this is to assign probabilistic labels $q(y(n))=P(y(n)\mid\mathbf{x}(n))$ to unlabeled inputs $\mathbf{x}(n)$ and try to train $P(y\mid\mathbf{x})$ using those labels: it can be shown (see, e.g., Raiko et al., 2015, Eq. (31)) that the gradient will vanish. There are different ways of circumventing this phenomenon by adjusting the assigned labels $q(y(n))$. These are all related to the $\Gamma$-model.

Label propagation methods (Szummer and Jaakkola, 2003) estimate $P(y\mid\mathbf{x})$, but adjust probabilistic labels $q(y(n))$ on the basis of the assumption that the nearest neighbors are likely to have the same label. The labels start to propagate through regions with high-density $P(\mathbf{x})$. The $\Gamma$-model implicitly assumes that the labels are uniform in the vicinity of a clean input since corrupted inputs need to produce the same label. This produces a similar effect: the labels start to propagate through regions with high density $P(\mathbf{x})$. Weston et al. (2012) explored deep versions of label propagation.

Co-training (Blum and Mitchell, 1998) assumes we have multiple views on $\mathbf{x}$, say $\mathbf{x}=(\mathbf{x}^{(1)},\mathbf{x}^{(2)})$. When we train classifiers for the different views, we know that even for the unlabeled data, the true label is the same for each view. Each view produces its own probabilistic labeling $q^{(j)}(y(n))=P(y(n)\mid\mathbf{x}(n)^{(j)})$ and their combination $q(y(n))$ can be fed to train the individual classifiers. If we interpret having several corrupted copies of an input as different views on it, we see the relationship to the proposed method.

Lee (2013) adjusts the assigned labels $q(y(n))$ by rounding the probability of the most likely class to one and others to zero. The training starts by trusting only the true labels and then gradually increasing the weight of the so-called pseudo-labels. Similar scheduling could be tested with our $\Gamma$-model as it seems to suffer from confirmation bias. It may well be that the denoising cost which is optimal at the beginning of the learning is smaller than the optimal one at later stages of learning.

Dosovitskiy et al. (2014) pre-train a convolutional network with unlabeled data by treating each clean image as its own class. During training, the image is corrupted by transforming its location, scaling, rotation, contrast, and color. This helps to find features that are invariant to the transformations that are used. Discarding the last classification layer and replacing it with a new classifier trained on real labeled data leads to surprisingly good experimental results.

Recently Miyato et al. (2015) achieved impressive results with a regularization method that is similar to the idea of contractive cost. They required the output of the network to change as little as possible close to the input samples. As this requires no labels, they were able to use unlabeled samples for regularization. While their semi-supervised results were not as good as ours with a denoising target on the input layer, their results with full labels come very close. Their cost function is on the last layer which suggests that the approaches are complementary and could be combined, potentially improving the results further.

So far we have reviewed semi-supervised methods which have an unsupervised cost function on the output layer only and therefore are related to our $\Gamma$-model. We will now move to other semi-supervised methods that concentrate on modeling the joint distribution of the inputs and the labels.

The Multi-prediction deep Boltzmann machine (MP-DBM) (Goodfellow et al., 2013a) is a way to train a DBM with backpropagation through variational inference. The targets of the inference include both supervised targets (classification) and unsupervised targets (reconstruction of missing inputs) that are used in training simultaneously. The connections through the inference network are somewhat analogous to our lateral connections. Specifically, there are inference paths from observed inputs to reconstructed inputs that do not go all the way up to the highest layers. Compared to our approach, MP-DBM requires an iterative inference with some initialization for the hidden activations, whereas in our case, the inference is a simple single-pass feedforward procedure.

The Deep AutoRegressive Network (Gregor et al., 2014) is an unsupervised method for learning representations that also uses lateral connections in the hidden representations. The connectivity within the layer is rather different from ours, though: each unit $h_{i}$ receives input from the preceding units $h_{1}\dots h_{i-1}$, whereas in our case each unit $\hat{z}_{i}$ receives input only from $z_{i}$. Their learning algorithm is based on approximating a gradient of a description length measure, whereas we use a gradient of a simple loss function.

Kingma et al. (2014) proposed deep generative models for semi-supervised learning, based on variational autoencoders. Their models can be trained with the variational EM algorithm, stochastic gradient variational Bayes, or stochastic backpropagation. They also experimented on a stacked version (called M1+M2) where the bottom autoencoder M1 reconstructs the input data, and the top autoencoder M2 can concentrate on classification and on reconstructing only the hidden representation of M1. The stacked version performed the best, hinting that it might be important not to carry all the information up to the highest layers. Compared with the Ladder network, an interesting point is that the variational autoencoder computes the posterior estimate of the latent variables with the encoder alone while the Ladder network uses the decoder too to compute an implicit posterior approximate (the encoder provides the likelihood part, which gets combined with the prior). It will be interesting to see whether the approaches can be combined. A Ladder-style decoder might provide the posterior and another decoder could then act as the generative model of variational autoencoders.

Zeiler et al. (2011) train deep convolutional autoencoders in a manner comparable to ours. They define max-pooling operations in the encoder to feed the max function upwards to the next layer, while the argmax function is fed laterally to the decoder. The network is trained one layer at a time using a cost function that includes a pixel-level reconstruction error, and a regularization term to promote sparsity. Zhao et al. (2015) use a similar structure and call it the stacked what-where autoencoder (SWWAE). Their network is trained simultaneously to minimize a combination of the supervised cost and reconstruction errors on each level, just like ours.

Recently Bengio (2014) proposed target propagation as an alternative to backpropagation. The idea is to base learning not on errors and gradients but on expectations. This is very similar to the idea of denoising source separation and therefore resembles the propagation of expectations in the decoder of the Ladder network. In the Ladder network, the additional lateral connections between the encoder and the decoder play an important role and it remains to be seen whether the lateral connections are compatible with target propagation. Nevertheless, it is an interesting possibility that while the Ladder network includes two mechanisms for propagating information, backpropagation of gradients and forward propagation of expectations in the decoder, it may be possible to rely solely on the latter, thus avoiding problems related to the propagation of gradients through many layers, such as exploding gradients.

Discussion

We showed how a simultaneous unsupervised learning task improves CNN and MLP networks reaching the state of the art in various semi-supervised learning tasks. In particular, the performance obtained with very small numbers of labels is much better than previous published results, which shows that the method is capable of making good use of unsupervised learning. However, the same model also achieves state-of-the-art results and a significant improvement over the baseline model with full labels in permutation invariant MNIST classification, which suggests that the unsupervised task does not disturb supervised learning.

The proposed model is simple and easy to implement with many existing feedforward architectures, as the training is based on backpropagation from a simple cost function. It is quick to train and the convergence is fast, thanks to batch normalization.

Not surprisingly, the largest improvements in performance were observed in models which have a large number of parameters relative to the number of available labeled samples. With CIFAR-10, we started with a model which was originally developed for a fully supervised task. This has the benefit of building on existing experience but it may well be that the best results will be obtained with models which have far more parameters than fully supervised approaches could handle.

An obvious future line of research will therefore be to study what kind of encoders and decoders are best suited to the Ladder network. In this work, we made very small modifications to the encoders, whose structure has been optimized for supervised learning, and we designed the parametrization of the vertical mappings of the decoder to mirror the encoder: the flow of information is just reversed. There is nothing preventing the decoder from having a different structure than the encoder.

An interesting future line of research will be the extension of the Ladder networks to the temporal domain. While datasets with millions of labeled samples for still images exist, it is prohibitively costly to label thousands of hours of video streams. The Ladder networks can be scaled up easily and therefore offer an attractive approach for semi-supervised learning in such large-scale problems.

Acknowledgements

We have received comments and help from a number of colleagues who all deserve to be mentioned but we wish to thank especially Yann LeCun, Diederik Kingma, Aaron Courville, Ian Goodfellow, Søren Sønderby, Jim Fan, and Hugo Larochelle for their helpful comments and suggestions. The software for the simulations for this paper was based on Theano (Bastien et al., 2012; Bergstra et al., 2010) and Blocks (van Merriënboer et al., 2015). We also acknowledge the computational resources provided by the Aalto Science-IT project. The Academy of Finland has supported Tapani Raiko.

References

Appendix A Specification of the convolutional models

Here we describe two model structures, Conv-Small and Conv-Large, that were used for the MNIST and CIFAR-10 datasets, respectively. They were both inspired by ConvPool-CNN-C by Springenberg et al. (2014). Table 4 details the model architectures and differences between the models in this work and ConvPool-CNN-C. It is noteworthy that this architecture does not use any fully connected layers, but replaces them with a global mean pooling layer just before the softmax function. The main differences between our models and ConvPool-CNN-C are the use of Gaussian noise instead of dropout and the convolutional per-channel batch normalization following Ioffe and Szegedy (2015). We also used 2x2 stride 2 max-pooling instead of 3x3 stride 2 max-pooling. LeakyReLU was used to speed up training, as mentioned by Springenberg et al. (2014). We utilized batch normalization to all layers, including the pooling layers. Gaussian noise was also added to all layers, instead of applying dropout in only some of the layers as with ConvPool-CNN-C.

Appendix B Formulation of the Denoising Function

The proposed parametrization of the denoising function was therefore:

In order to test whether the elements of the proposed function $g$ were necessary, we systematically removed components from $g$ or replaced $g$ altogether and compared the resulting performance to the results obtained with the original parametrization. We tuned the hyperparameters of each comparison model separately using a grid search over some of the relevant hyperparameters. However, the standard deviation of additive Gaussian corruption noise was set to 0.3. This means that the comparison does not include the best-performing models reported in Table 1 that achieved the best validation errors after more careful hyperparameter tuning.

The comparison functions $g_{1\ldots 4}$ are parametrized as follows:

$g_{3}$ differs from $g$ in that it is linear and does not have a sigmoid term. As this formulation is linear, it only supports Gaussian distributions. Although the parametrization has the augmented term that lets $u$ modulate the slope and shift of the distribution, the scope of possible denoising functions is still fairly limited.

All models were tested in a similar setting as the semi-supervised fully connected MNIST task using $N=1000$ labeled samples. We also reran the best comparison model on $N=100$ labels. The results of the analyses are presented in Table 5.

As can be seen from the table, the alternative parametrizations of g are inferior to the proposed parametrization, at least in the model structure we use.

In addition to the alternative parametrizations for the g-function, we ran experiments using a more standard autoencoder structure. In that structure, we attached an additional decoder to the standard MLP by using one hidden layer as the input to the decoder and the reconstruction of the clean input as the target. The structure of the decoder was set to be the same as the encoder: that is, the number and size of the layers from the input to the hidden layer where the decoder was attached were the same as the number and size of the layers in the decoder. The final activation function in the decoder was set to be the sigmoid nonlinearity. During training, the target was the weighted sum of the reconstruction cost and the classification cost.

We tested the autoencoder structure with 100 and 1000 labeled samples. We ran experiments for all possible decoder lengths: that is, we tried attaching the decoder to all the hidden layers. However, we did not manage to get a significantly better performance than the standard supervised model without any decoder in any of the experiments.