Good old on-line back-propagation for plain multi-layer perceptrons yields a very low 0.35 we need to achieve this best result so far are many hidden layers, many neurons per layer, numerous deformed training images, and graphics cards to greatly speed up learning.READ FULL TEXT VIEW PDF
Greedy Restrictive Boltzmann Machines yield an fairly low 0.72
The competitive MNIST handwritten digit recognition benchmark has a long...
In this paper, a simple, general method of adding auxiliary stochastic
Despite the phenomenal success of deep learning in recent years, there
This work attempts to find the most optimal parameter setting of a deep
Understanding the representational power of Restricted Boltzmann Machine...
Data-target association is an important step in multi-target localizatio...
A convolutional neural network for handwritten kanji recognition, written using Keras. Uses elastic distortions for dataset augmentation.
Automatic handwriting recognition is of great academic and commercial interest. Current algorithms are already pretty good at learning to recognize handwritten digits. Post offices use them to sort letters; banks use them to read personal checks. MNIST (LeCun et al., 1998) is the most widely used benchmark for isolated handwritten digit recognition. More than a decade ago, artificial neural networks called Multilayer Perceptrons or MLPs (Werbos, 1974; LeCun, 1985; Rumelhart et al., 1986)
were among the first classifiers tested on MNIST. Most had few layers or few artificial neurons (units) per layer(LeCun et al., 1998), but apparently back then they were the biggest feasible MLPs, trained when CPU cores were at least 20 times slower than today. A more recent MLP with a single hidden layer of 800 units achieved 0.70% error (Simard et al., 2003)
. However, more complex methods listed on the MNIST web page always seemed to outperform MLPs, and the general trend went towards more and more complex variants of Support Vector Machines or SVMs(Decoste & Scholkopf, 2002) and combinations of NNs and SVMs (Lauer et al., 2007)
etc. Convolutional neural networks (CNNs) achieved a record-breaking 0.40% error rate(Simard et al., 2003)
, using novel elastic training image deformations. Recent methods pre-train each hidden CNN layer one by one in an unsupervised fashion (this seems promising especially for small training sets), then use supervised learning to achieve 0.39% error rate(Ranzato et al., 2006, 2007). The biggest MLP so far (Salakhutdinov et al., 2007) also was pre-trained without supervision then piped its output into another classifier to achieve an error of 1% without domain-specific knowledge.
Are all these complexifications of plain MLPs really necessary? Can’t one simply train really big plain MLPs on MNIST? Why is there no literature on this? One reason is that at first glance deep MLPs do not seem to work better than shallow networks (Bengio et al., 2006). Training them is hard as back-propagated gradients quickly vanish exponentially in the number of layers (Hochreiter, 1991; Hochreiter et al., 2001; Hinton, 2007)
, just like in the first recurrent neural networks(Hochreiter & Schmidhuber, 1997). Indeed, previous deep networks successfully trained with back-propagation (BP) either had few free parameters due to weight-sharing (e.g. LeCun et al., 1998; Simard et al., 2003) or used unsupervised, layer-wise pre-training (e.g. Bengio et al., 2006; Ranzato et al., 2006)
. But is it really true that deep BP-MLPs do not work at all, or do they just need more training time? How to test this? Unfortunately, on-line BP for hundreds/thousands of epochs on large MLPs may take weeks or months on standard serial computers. But can’t one parallelize it? Well, on computer clusters this is hard due to communication latencies between individual computers. Multi-threading on a multi-core processor is not easy either. We may speed up BP using SSE (Streaming Single Instruction, Multiple Data Extensions), either manually, or by setting appropriate compiler flags. The maximum theoretical speedup under single precision floating-point, however, is four, which is not enough. And MNIST is large - its 60,000 images take almost 50MB, too much to fit in the L2/L3 cache of any current processor. This requires to continually access data in considerably slower RAM. To summarize, currently it is next to impossible to train big MLPs on CPUs.
We will show how to overcome all these problems by training large, deep MLPs on graphics cards.
MNIST consists of two datasets, one for training (60,000 images) and one for testing (10,000 images). Many studies divide the training set into two sets consisting of 50,000 images for training and 10,000 for validation. Our network is trained on slightly deformed images, continually generated in on-line fashion; hence we may use the whole un-deformed training set for validation, without wasting training images. Pixel intensities of the original gray scale images range from 0 (background) to 255 (max foreground intensity). pixels per image get mapped to real values in , and are fed into the NN input layer.
We train 5 MLPs with 2 to 9 hidden layers and varying numbers of hidden units. Mostly but not always the number of hidden units per layer decreases towards the output layer (Table 1
). There are 1.34 to 12.11 million free parameters (or weights, or synapses).
We use standard on-line BP (e.g. Russell & Norvig, 2002, pages 744-748), without momentum, but with a variable learning rate that shrinks by a multiplicative constant after each epoch, from down to . Weights are initialized with a uniform random distribution in
. Each neuron’s activation function is a scaled hyperbolic tangent:, where and (LeCun et al., 1998).
So far, the best results on MNIST were obtained by deforming training images, thus greatly increasing their number. This allows for training networks with many weights, making them insensitive to in-class variability. We combine affine (rotation, scaling and horizontal shearing) and elastic deformations, characterized by the following real-valued parameters:
and : for elastic distortions emulating uncontrolled oscillations of hand muscles (for details see Simard et al., 2003);
: a random angle from describes either rotation or horizontal shearing. In case of shearing, defines the ratio between horizontal displacement and image height;
, : for horizontal and vertical scaling, randomly selected from .
At the beginning of every epoch the entire MNIST training set gets deformed. Initial experiments with small networks suggested the following deformation parameters: , , . Since digits 1 and 7 are similar they get rotated/sheared less () than other digits ().
All simulations were performed on a computer with a Core2 Quad 9450 2.66GHz processor, 3GB of RAM, and a GTX280 graphics card. The GPU accelerates the deformation routine by a factor of 10 (only elastic deformations are GPU-optimized); the forward propagation (FP) and BP routines are sped up by a factor of 40. Implementation details can be found in the Appendix. We pick the trained MLP with the lowest validation error, and evaluate it on the MNIST test set. Results are summarized in Table 1.
Most remarkably, the best network has an error rate of only 0.35% (35 out of 10,000 digits). This is significantly better than the best previously published results, namely, 0.39% by Ranzato et al. (2006) and 0.40% by Simard et al. (2003), both obtained by more complex methods. The 35 misclassified digits are shown in Figure 1. Many of them are ambiguous and/or uncharacteristic, with obviously missing parts or strange strokes etc. Interestingly, the second guess of the network is correct for 30 out of the 35 misclassified digits.
The best test error of this MLP is even lower (0.32%) and may be viewed as the maximum capacity of the network. Performance clearly profits from adding hidden layers and more units per layer. For example, network 5 has more but smaller hidden layers than network 4 (Table 1).
Networks with up to 12 million weights can successfully be trained by plain gradient descent to achieve test errors below 1% after 20-30 epochs in less than 2 hours of training. How can networks with so many parameters generalize well on the unseen test set? Answer: the continual deformations of the training set generate a virtually infinite supply of training examples, and the network rarely sees any training image twice.
|ID||architecture||test error for||best test||simulation||weights|
|(number of neurons in each layer)||best validation [%]||error [%]||time [h]||[milions]|
|1||1000, 500, 10||0.49||0.44||23.4||1.34|
|2||1500, 1000, 500, 10||0.46||0.40||44.2||3.26|
|3||2000, 1500, 1000, 500, 10||0.41||0.39||66.7||6.69|
|4||2500, 2000, 1500, 1000, 500, 10||0.35||0.32||114.5||12.11|
|5||9 1000, 10||0.44||0.43||107.7||8.86|
In recent decades the amount of raw computing power per Euro has grown by a factor of 100-1000 per decade. Our results show that this ongoing hardware progress may be more important than advances in algorithms and software (although the future will belong to methods combining the best of both worlds). Current graphics cards (GPUs) are already more than 40 times faster than standard microprocessors when it comes to training big and deep neural networks by the ancient algorithm, on-line back-propagation (weight update rate up to , and more than
per trained network). On the very competitive MNIST handwriting benchmark, single precision floating-point GPU-based neural nets surpass all previously reported results, including those obtained by much more complex methods involving specialized architectures, unsupervised pre-training, combinations of machine learning classifiers etc. Training sets of sufficient size are obtained by appropriately deforming images. Of course, the approach is not limited to handwriting, and obviously holds great promise for many visual and other pattern recognition problems.
Part of this work got started when Dan Cireşan was a PhD student at University ”Politehnica” of Timişoara. He would like to thank his former PhD advisor, Ştefan Holban, for his guidance, and Răzvan Moşincat for providing a CPU framework for MNIST. This work was supported by Swiss CTI, Commission for Technology and Innovation, Project n. 9688.1 IFF: Intelligent Fill in Form, and by Lifeware S.A. L.M.G. and J.S. wrote a grant proposal for this work, acquired competitive funding for it, and supervised it. C.D.C. wrote GPU-optimised code. C.D.C. and U.M. debugged it. C.D.C. designed and performed the experiments. C.D.C., U.M., L.M.G. and J.S. wrote the paper.
Until 2007 the only way to program a GPU was to translate the problem-solving algorithm into a set of graphical operations. Despite being hard to code and difficult to debug, several GPU-based NN implementations were developed when GPUs became faster than CPUs. Two layer MLPs (Steinkraus et al., 2005) and CNNs (Chellapilla et al., 2005) have been previously implemented on GPUs. Although speedups were relatively modest, these studies showed how GPUs can be used for machine learning. More recent GPU-based CNNs trained in batch mode are two orders of magnitude faster than CPU-based CNNs (Scherer & Behnke, 2009).
In 2007, NVIDIA developed the first version of CUDA (Compute Unified Device Architecture), a C-like general programming language. GPU speed and memory bandwidth are vastly superior to those of CPUs, and crucial for fast MLP implementations. To fully understand our algorithm in terms of GPU / CUDA, please visit the NVIDIA website (NVIDIA, 2009). According to CUDA terminology, the CPU is called host and the graphics card device or GPU.
It takes 93 CPU seconds to deform the 60,000 MNIST training images, most of them (87) for elastic distortions. Only the most time-consuming part of the latter – convolution with a gaussian kernel (Simard et al., 2003) – is ported to the GPU. The MNIST training set is split into 600 sequentially processed batches. MNIST digits are scaled from the original pixels to pixels, to get a proper center, which simplifies convolution. An image grid has 290
290 cells, zero-padded to 300300, thus avoiding margin effects when applying a gaussian convolution kernel of size .
Our GPU program groups many threads into a block, where they share the same gaussian kernel and parts of the random field. The blocks contain 21 (the kernel size) 10 threads, each computing a vertical strip of the convolution operation (Listing 1).
Generating the elastic displacement field takes only 3 seconds. Deforming the whole training set is more than 10 times faster, taking 9 instead of the original 93 seconds. Further optimization would be possible by porting all deformations onto the GPU, and by using the hardware’s interpolation capabilities to perform the final bilinear interpolation. We omitted this since deformations are already pretty fast (deforming all images of one epoch takes only 5-15 % of total computation time, depending on MLP size).
We closely follow the standard BP algorithm (e.g. Russell & Norvig, 2002, pages 744-748), except that BP of deltas and weight updates are disentangled and performed sequentially. This allows for more parallelism within each routine.
The algorithm is divided into two kernels. The weight matrix is partitioned as illustrated in Figure 2.
Each block has 256 threads (Figure 2a), each computing a partial dot product of 32 component vectors. The dot products are stored in a temporary matrix (Figure 2b). This kernel has a very high throughput: average memory bandwidth is 115GB/s. This is possible because many relatively small blocks keep the GPU busy. Each block uses shared memory for storing the previous layer activations, which are simultaneously read by the first 32 threads of each block and then used by all 256 threads. After thread synchronization, the partial dot products are computed in parallel (Listing 2). The number of instructions is kept to a minimum by pre-computing all common index parts.
The thread grid (Figure 2b) has only one row of blocks consisting of threads, since each thread has to compute a complete dot product (Figure 2c) and then pipe it into the activation function. This kernel (Listing 2) is inefficient for layers with fewer than 1024 incoming connections per neuron, especially for the last layer which has only ten neurons, one for each digit. That is, its grid will have only one block, occupying only 3% of the GTX280 GPU.
This is similar to FP, but we need for coalesced access. Instead of transposing the matrix, the computations are performed on patches of data read from device memory into shared memory, similar to the optimized matrix transposition algorithm of Ruetsch & Micikevicius (2009). Shared memory access is much faster, without coalescing restrictions. Because we have to cope with layers of thousands of neurons, back-propagating deltas uses a reduction method implemented in two kernels communicating partial results via global memory (Listing 3).
Kernel 1 The bi-dimensional grid is divided into blocks of (32) threads. The kernel starts by reading a patch of values from W. The stride of the shared memory block is 33 (), thus avoiding all bank conflicts and significantly improving speed. Next, 32 input delta values are read and all memory locations that do not correspond to real neurons (because of vertical striding) are zero-padded to avoid branching in subsequent computations. The number of elements is fixed to size, and the computing loop is unrolled for further speedups. Before finishing, each thread writes its own partial dot product to global memory.
This kernel completes BP of deltas by summing up partial deltas computed by the previous kernel. It multiplies the final result by the derivative of the activation function applied to the current neuron’s state, and writes the new delta to global memory.
The algorithm (Listing 4) starts by reading the appropriate delta, and pre-computes all repetitive expressions. Then the first 16 threads read the states from global memory into shared memory. The “bias neuron” with constant activation 1.0 is dealt with by conditional statements, which could be avoided through expressions containing the conditions. Once threads are synchronized, each single thread updates 16 weights in a fixed unrolled loop.
Proc. Computer Vision and Pattern Recognition Conference (CVPR’07).
Efficient Learning of Sparse Representations with an Energy-Based Model.Advances in Neural Information Processing Systems (NIPS 2006).