zlinnet
Source code for ``How far can we go without convolution: Improving fully-connected networks`` published at ICLR 2016 workshop
view repo
We propose ways to improve the performance of fully connected networks. We found that two approaches in particular have a strong effect on performance: linear bottleneck layers and unsupervised pre-training using autoencoders without hidden unit biases. We show how both approaches can be related to improving gradient flow and reducing sparsity in the network. We show that a fully connected network can yield approximately 70 the permutation-invariant CIFAR-10 task, which is much higher than the current state-of-the-art. By adding deformations to the training data, the fully connected network achieves 78 convolutional network.
READ FULL TEXT VIEW PDF
Convolutional neural networks (CNN) exhibit unmatched performance in a
m...
read it
In this work we introduce a differentiable version of the Compositional
...
read it
Convolution is one of the most essential components of architectures use...
read it
We propose a novel way of reducing the number of parameters in the
stora...
read it
Artificial Neural Networks form the basis of very powerful learning meth...
read it
Convolutional neural networks often dominate fully-connected counterpart...
read it
Simulations of high energy density physics are expensive in terms of
com...
read it
Source code for ``How far can we go without convolution: Improving fully-connected networks`` published at ICLR 2016 workshop
Convolutional neural networks (CNN) have had huge successes since Krizhevsky et al. (2012)
, especially in computer vision applications. The main computational idea behind these,
weight sharing, is unfortunately not biologically plausible, and it does not map nicely to simple, densely parallel hardware designs, which may one day yield lower-energy, and more efficient ways to run neural networks. The reason is that weight sharing requires long-range communication, for example, when distributing derivatives, during learning.In this paper, we explore the performance that one can possibly achieve with a neural network without convolutions, in other words, a neural network learning on “permutation invariant” classification tasks. We use these as a test-bed for studying alternative architectural design choices beside convolution, which are biologically plausible and potentially more hardware friendly. Studying these design choices is relevant also because many tasks and sub-tasks do not come with any local translation invariance, making them not amenable to convolution (an example being the hidden layer in a recurrent neural network).
Two architectural choices we found to have a strong impact on performance are (i) linear bottleneck layers and (ii) pre-training using autoencoders whose hidden units have no biases. Taken together, these two approaches allow us a network to achieve state-of-the-art performance on the permutation-invariant CIFAR-10 task ^{1}^{1}1An example implementation that generates the state-of-the-art on this task is available at https://github.com/hantek/zlinnet, and by adding deformations (thus removing the permutation invariance requirement) it achieves performance close to the range of that achieved by CNNs.
Both approaches can be viewed from the perspective of sparsity in a neural network. Sparsity is commonly considered as a desirable property in machine learning models, and it is often encouraged explicitly as a regularizer. Unfortunately, in deep, multilayer neural networks sparsity comes at a price: in common activation functions, such as sigmoid or ReLU, zero (or almost zero) activations are attained at values where derivatives are zero, too. This prevents derivatives from flowing through inactive hidden units, and makes the optimization difficult. Stated in terms of the vanishing gradients problem (e.g.,
Hochreiter et al. (2001)) this means that for a ReLU activation many Jacobians are diagonal matrices containing many zeros along the diagonal.To alleviate this problem, recently several activation functions were proposed, where zero derivatives do not, or are less likely to, occur. In the PReLU activation function (He et al., 2015), for example, the zero-derivative regime is replaced by a learned, and typically small-slope, linear activation. Another approach is the Maxout activation (Goodfellow et al., 2013)
, which is defined as the maximum of several linear activations. Accordingly, preventing zero-derivatives this way was shown to improve the optimization and the performance of multilayer networks. Unfortunately, these methods solve the problem by giving up on sparsity altogether, which raises the question whether sparsity is simply not as desirable as widely assumed or whether the benefit of the optimization outweigh any detrimental effect on sparsity. Sparsity also plays a crucial role in unsupervised learning (which can also be viewed as a way to help the optimization
(Saxe et al., 2013)), where these activations have accordingly never been successfully applied.This view of sparsity motivates us to revisit a simple, but as we shall show surprisingly effective, approach to retaining the benefits of sparsity without preventing gradient-flow. The idea is to inter-leave linear, low-dimensional layers with the sparse, high-dimensional layers containing ReLU or sigmoid activations. We show that this approach outperforms equivalent PReLU and Maxout networks on the fully supervised, permutation invariant CIFAR-10 task.
A second detrimental side-effect of sparsity, discussed in more detail in Konda et al. (2014), is that for a ReLU or sigmoid unit to become sparse it typically learns strongly negative bias-terms. In other words, while sparse activations can be useful in terms of the learning objective (for example, by allowing the network to carve up space into small regions) it forces the network to utilize bias terms that are not optimal for the representation encoded in hidden layer activations. Konda et al. (2014), for example, suggest bias-terms equal to zero to be optimal and propose a way to train an autoencoder with zero-bias hidden units. We suggest in Section 3 that pre-training a network with these autoencoders may be viewed as a way to orthogonalize subsets of weights in the network, and show that this yields an additional strong performance improvement.
One drawback of sparsity in a deep network is that it amounts to data scarcity: a weight whose post-synaptic unit is off of the time will effectively get to see only of the training data. In lower layers of a convolutional network, this problem is compensated by weight-sharing, which increases the effective number of training examples (patches in that case) per weight by a factor of several thousand. In a fully connected layer (more precisely, a layer without weight sharing) such compensation is not possible and the only way to counter this effect would be by increasing the training set size.
Sparsity is a common and stable effect in neural networks containing ReLU or sigmoid units, and it can be related to the fact the biases are driven to zero in response to regularization (eg., Konda et al. (2014)). Figure 1 (left) shows the sparsity level attained after training ReLU MLPs. ^{2}^{2}2Two MLPs (1000-2000-3000 units and 2000-2000-2000 units, respectively), trained for epochs on CIFAR-10. Each network was trained once with dropout and once without. For the experiments with dropout, an input noise level of and hidden noise level of was used. The plots show that the sparsity of the hidden presentation increases with the depth of the network and increase further in the presence of dropout.
It is well-known that different activation functions work best when the input is in a reasonable scale, which is the motivation for using pre-processing by mean subtraction and scaling, for example. Furthermore, incorporating them into hidden unit activation, can yield further performance improvements (Ioffe & Szegedy, 2015).
Here, we focus on the distribution over the outputs of a unit. The output of a linear neuron
with inputs is given by whereis the entry in the weight vector corresponding to input node
, is the bias of the linear neuron, and denotes the input dimension. Assume the data fed into each input node is independent and has a finite meanand variance
. In the net input to a neuron, the mean and variance of each term are tuned by its corresponding weight values:(1) |
According to the Lyapunov theorem (DeGroot et al., 1986)
, if a sequence of random variables with finite mean and variance are independent but not necessarily identically distributed, the distribution of the sum:
(2) |
tends to standard Gaussian distribution for
. If we write in terms of , that is, we see that approximates a Gaussian distribution whose mean is and whose variance equals to , when the input dimension . For mean-centered data, we have . Thus the actual mean value of is merely dominated by in which case the p.d.f. of is:(3) |
This form of asymptotic distribution holds regardless of the weight . That means, no matter how the network is trained, or even not trained, the asymptotic distribution of output of a linear unit tends to be Gaussian.
Since the pre-hidden activation of ReLU is linear it tends to be Gaussian as well. The ReLU activation then simply sets all negative values to zero which yields:
(4) |
where is the Dirac delta. The distribution has a delta spike at zero and a Gaussian tail at its positive end (Figure 2).
Since the bias controls the intensity of the spike, it controls the sparsity of output representation (left plot). The observation that biases tend to zero motivated Konda et al. (2014) to introduce a “zero-bias” activation function which uses a fixed threshold followed by linear activation. Typically while using zero-bias ReLU, a threshold of 1 is introduced during pre-training stage, and set back to zero while training its subsequent layers and fine-tuning. The distribution of pre-hidden activity of a zero-bias ReLU stretches equally on both sides of zero. As a result, for zero-bias ReLU activation half of the probability mass concentrates on a delta spike located at zero, as illustrated it Figure 2
(right). While batch normalization alone will push the mean and variance into the optimal range for a subsequent ReLU unit, it will not resolve the issue that the distribution is peaked at the negative bias. In fact, the estimate of mean and variance will suffer from the presence of a highly non-Gaussian distribution. Typical histograms over hidden unit activations for several activation functions are shown in Figure
2(a).We now consider the derivatives of a ReLU network. The activation of the -th layer is given by:
(5) |
where is the element-wise activation function. The back-propagated updates on will be:
(6) |
where stands for the down flowing error signal coming from the upper layer, stands for element-wise multiply, and is the product of a vertical vector and a horizontal vector. As discussed in Section 2.1, at least 50% (usually much more in practice due to negative biases) of the values in the representation and are typically equal to zero (cf., Figure 1, left) making a large fraction of the entries of per training case zero. If we introduce a linear layer between two ReLU layers,
(7) |
where stands for the output of linear layer, and , are the weights and biases in the linear layer, we obtain updates of the form:
(8) |
where is the error signal passed to the linear layer, . Since the linear layer representation is dense, both and become denser: only half of the values in these two update matrices are zeros. More importantly, there always exists a simple ReLU layer that is equivalent to a ReLU/linear combination because any linear layer can be absorbed into the weights of the ReLU layer:
(9) |
Then, the equivalent update on becomes:
(10) |
Even if half of the values in and are zero, their product is a dense matrix. The second and third term in Equation 10 are also dense, so with a linear bottleneck layer, we actually obtain a dense update in an equivalent ReLU layer.
Besides helping with back propagation, it is important to note that linear layers also reduce the total number of parameters. Suppose a linear layer with units is inserted between two nonlinear layers with units each. The total number of parameters would become . This is much less than the number of parameters that would result from directly connecting the two nonlinear layer, which would amount to parameters. Convolutional network also reduces the number of parameters by convolution kernels. Note that for any trained convolutional network, we can always find a fully connected network with the same accuracy by expanding the convolutional kernels.
It was suggested by Saxe et al. (2013) that the benefit of unsupervised pre-training of a network using RBMs or autoencoders may result in weight matrices that are closer to orthogonal and thus less affected by vanishing gradients problems. It is interesting to note, however, that the sparsity-inducing negative biases yield reconstructions that are affine not linear and accordingly may not orthogonalize weights after all (Konda et al., 2014)
. This may be one of the reasons why the practical success of these pre-training schemes has been quite limited by comparison to fully supervised learning using back propagation.
It is also important to note that due to sparsity, the number of active units in a layer is often smaller than that the same number in the layer below, so the “effective” weight matrix for a given input example is not a square matrix. Rather than simply orthogonal weight matrices, we should be looking for networks where hidden units which tend to be active on the same inputs have weights that tend to be orthogonal to one another. In other words, we should be looking for “orthogonal active paths” through the network rather than overall orthogonal weight matrices.
In order to obtain hidden units with linear not affine encodings Konda et al. (2014) introduce “zero-bias autoencoders” (ZAE) whose activations are threshold-ed when pre-trained by minimizing the autoencoder reconstruction error, and whose thresholds are removed when the weights are used for classification or for initializing a feed forward network. As discussed in Konda et al. (2014) minimizing squared error under the linear encoding should encourage weights corresponding to hidden units that tend to be “on” together to orthogonalize (because the orthogonal projection is what minimizes reconstruction error). Konda et al. (2014) reported decent classification performance in various supervised tasks, but found only a weak improvement over standard autoencoders when used to initialize a single-hidden-layer MLP.
The view of a zero-bias activation function as a way to orthogonalize weights suggests especially deep networks to profit from ZAE pre-training, and so we investigated the performance of ZAE-pretrained networks with many hidden layers, as well as in conjunction with interleaved bottleneck layers (as discussed in Section 2). We found them to yield a separate, and significant, performance improvement in fully connected networks.
The CIFAR-10 dataset is a subset of the 80 Million Tiny Images Torralba et al. (2008), and contains balanced classes. It provides a training set with samples and a test set of samples. Each sample is a color image with RGB pixels. We first compare mixed models with linear bottleneck layers and ordinary networks. We compare two different activation functions: ReLU and zero-bias ReLU (Konda et al., 2014)
. Comparison are based on classification accuracy. All the experiments in this subsection share the same pre-processing pipeline and the same type of classifier. For pre-processing, the raw data is contrast normalized and centered to have zero mean, followed by PCA whitening, retaining 99% of the variance.
We trained 3 ReLU networks with different configurations, and compare their results with the ReLU-Lin network , that interleaves a linear layer between two ReLU layers. All networks in Figure 3(a)
are trained by supervised back propagation using stochastic gradient descent with 0.9 momentum. The ReLU-Lin network outperforms all the pure ReLU networks and reaches an accuracy of 56.84%. We also found that the ReLU-Lin network tends to be more stable than the pure ReLU networks: if we pre-train these networks layer-wise, then for the ReLU networks the majority of the units in higher layers become “dead”, whereas the ReLU-Lin network is still stable for unsupervised pre-training without dead units at the second ReLU layer.
We repeat the same experiment by substituting ReLU with ZAE (Figure 3(b)). The Z-Lin network is configured as (same as in Figure 1, but with only one Z-Lin pair). Since ZAE does not suffer from the problem of dead units that much as ReLU, all the networks are first layer-wise pre-trained in an autoencoder, and then fine-tuned with stochastic gradient descent. During pre-training the linear layer, we have 1.0 weight decay added to the cost. Similar to the case of ReLU, it is also observed that introducing linear bottleneck layers makes the stacked deeper model outperform its shallow counterpart. Having a linear inserted in the middle makes the Z-Lin model outperform all the other models, yielding an accuracy of 65.76%.
We also compare the bottleneck layer structure with other related modifications like PReLU (He et al., 2015) and Maxout (Goodfellow et al., 2013), the bottleneck structure performs better than both of them, if we apply it on the same network architecture. In comparison to batch normalization (Ioffe & Szegedy, 2015) (but on fully connected networks) on the other hand, their improvements are about the same.
The HIGGS dataset has million samples with dimensions. The first features are kinematic properties measured by particle detectors in a particle accelerator, and the remaining features are functions of the first 21 features. Thus the dataset itself is permutation invariant. The task is to decide if or not a given sample corresponds to a Higgs Boson.
We tried both ReLU and ZAE with/without linear bottleneck layers on this dataset. Similar to before, for each model PCA whitening retaining of the variance is used for pre-processing. (corresponding to principle components). We use the same model size for four different models that we compare (zero-bias ReLU, Z-Lin, ReLU, and ReLU-Lin). The structure is for all, so the models differ by using different activation functions. We train all the models using SGD with momentum, and tune learning rates individually. We do not use any pre-training. The results are shown in Figure 3(c), which also confirm the effectiveness of the bottleneck layers, albeit not as pronounced as on the CIFAR-10 data. Also, zero-bias units do not yield an improvement here.
In this subsection we explore how the network’s performance is affected by increasingly reducing the number of parameters, using bottlenecks of different sizes.
We define a network by stacking
Z-LIN pairs, plus a ZAE layer and a logistic regression classifier. Each ZAE layer has
hidden units. We reduce the linear layer size from down to units. Training involves dropout, pre-training and fine-tuning. The results are shown in Figure 5. We observe that even with a hidden layer of size , which has only of the parameters, the network still works reasonably well and does not loose too much accuracy.A 7-layer fully connected network with units each layer has around million parameters. With linear layers, the smallest model in Figure 5 has only around million parameters. By comparison, a typical convolutional network yielding an accuracy higher than 80% on CIFAR10 would have around million parameters.
We compare the performance of the Z-Lin model with other published methods on the CIFAR-10. For our method, pre-processing steps are the same to Section 4.1. For the Z-Lin network, each ZAE layer hidden units, and each linear autoencoder has hidden units. We use logistic regression on top of the last ZAE layer for classification. Following Konda et al. (2014), the threshold of all ZAEs are fixed at during pre-training, and set to
while training the subsequent layers and performing fine-tuning. As before, we subtract the mean value and normalize the activations to have a standard deviation of
in all layers.We train the networks using stochastic gradient descent with momentum and decreasing learning rate. The learning rate is set to for the ZAEs and to for the linear autoencoder. Weight decay is used for the linear autoencoder and for the logistic regression layer. The latter is trained using nonlinear conjugate gradients. After pre-training, we use a tiny learning rate of to fine-tune the whole network, which yields an overall accuracy of . This already outperforms all previous published permutation invariant CIFAR-10 results, the next best-performing of which are (Le et al., 2013), and (Konda et al., 2014).
By adding dropout (Srivastava et al., 2014) during pre-training and fine-tuning, and using a very deep Z-LIN network ( Z-LIN pairs, plus a ZAE layer and logistic regression classifier, i.e., ) the performance improves to , which exceeds the current state-of-the-art on permutation invariant CIFAR10 by a very large margin.
If we give up on permutation-invariance by using data augmentation (eg., Krizhevsky et al. (2012)) but retain the use of a fully connected network, the performance improves much further. Here, we add flipping, rotation, and shifting to the original data during training of a Z-LIN network pushing the performance to . This is a much higher accuracy on CIFAR-10 achieved by any fully connected network we are aware of, and it is only about behind a well-trained convolutional network.
The idea of a linear bottleneck layer is very old and has been used as early as the ’s in the context of autoencoders (eg., Baldi & Hornik (1989)). More recently, Ba & Caruana (2014) used a linear bottleneck layer to factorize a single-layer network and showed that it helped speed up learning. An application of a linear bottleneck layer in the last layer of a neural network for dealing with high-dimensional outputs is described in Sainath et al. (2013) and Xue et al. (2013). In contrast to our work, in none of these methods is the goal to alleviate vanishing gradients and deal with sparsity, and (accordingly) they use just a single bottleneck layer in the network.
Reshape distributions over activations using linear layers is also related to the recently introduced batch-normalization trick (Ioffe & Szegedy, 2015), in that it is also a way to adjust the distribution of inputs to a subsequent layer. In contrast to that work, linear bottleneck layers not only adjust the mean and variance of the inputs to the subsequent layer, but reshape the whole distribution.
It is well known that a single-hidden-layer neural network can model any non-linear function under mild conditions (Funahashi, 1989; Cybenko, 1989). The intuition behind this observation is that the hidden layer carves up space into half-spaces, or “tiles”, and the subsequent linear layer composes the non-linear function by combining different linear regions to produce the output. It is interesting to note that this view may suggest using a pair of layers (a non-linear followed by a linear layer) to define the non-linear function, leading thus to interleaved linear/non-linear layers.
The practical usefulness of this result is limited, however, because to approximate any given function it would require an exponentially large number of hidden units. In practice, this is one motivation for using multilayer networks which compute a sequence of consequently more restricted, but tractable non-linear functions. Arguably, in the presence of enough training data and computational resources, wide hidden layers would still be preferable to narrow ones. However, in practice, wider hidden layers also entail more sparsity, which prevents the flow of derivatives. Also, as sparse activations propagate upwards through the network, they tend to proliferate, aggravating the problem in higher layers.
Neural networks and principal component analysis: Learning from examples without local minima.
Neural networks, 2(1), 1989.Approximation by superpositions of a sigmoidal function.
Mathematics of control, signals and systems, 2(4):303–314, 1989.80 million tiny images: A large data set for nonparametric object and scene recognition.
Pattern Analysis and Machine Intelligence, IEEE Transactions on, 30(11):1958–1970, 2008.Restructuring of deep neural network acoustic models with singular value decomposition.
2013.
Comments
There are no comments yet.