Fractional Max Pooling implementation in Theano
Convolutional networks almost always incorporate some form of spatial pooling, and very often it is alpha times alpha max-pooling with alpha=2. Max-pooling act on the hidden layers of the network, reducing their size by an integer multiplicative factor alpha. The amazing by-product of discarding 75 of your data is that you build into the network a degree of invariance with respect to translations and elastic distortions. However, if you simply alternate convolutional layers with max-pooling layers, performance is limited due to the rapid reduction in spatial size, and the disjoint nature of the pooling regions. We have formulated a fractional version of max-pooling where alpha is allowed to take non-integer values. Our version of max-pooling is stochastic as there are lots of different ways of constructing suitable pooling regions. We find that our form of fractional max-pooling reduces overfitting on a variety of datasets: for instance, we improve on the state-of-the art for CIFAR-100 without even using dropout.READ FULL TEXT VIEW PDF
Recently, dropout has seen increasing use in deep learning. For deep
Although complicated and deep neural network models can achieve high acc...
Recently, dropout has seen increasing use in deep learning. For deep
Deep neural networks with alternating convolutional, max-pooling and
Many theories have emerged which investigate how in- variance is generat...
Most convolutional neural networks use some method for gradually downsca...
Pooling is an important component in convolutional neural networks (CNNs...
Fractional Max Pooling implementation in Theano
CIFAR-10 Object Detection with improved accuracy using Fractional MaxPooling with Convolutional Neural Networks
Convolutional networks are used to solve image recognition problems. They can be built by combining two types of layers:
Layers of convolutional filters.
Some form of spatial pooling, such as max-pooling.
Research focused on improving the convolutional layers has lead to a wealth of techniques such as dropout , DropConnect , deep networks with many small filters, large input layer filters for detecting texture , and deeply supervised networks .
By comparison, the humble pooling operation has been slightly neglected. For a long time max-pooling (MP2 has been the default choice for building convolutional networks. There are many reasons for the popularity of MP2-pooling: it is fast, it quickly reduces the size of the hidden layers, and it encodes a degree of invariance with respect to translations and elastic distortions. However, the disjoint nature of the pooling regions can limit generalization. Additionally, as MP2-pooling reduces the size of the hidden layers so quickly, stacks of back-to-back convolutional layers are needed to build really deep networks [7, 9, 11]. Two methods that have been proposed to overcome this problems are:
Stochastic pooling, where the act of picking the maximum value in each pooling region is replaced by a form of size-biased sampling .
However, both these techniques still reduce the size of the hidden layers by a factor of two. It seems natural to ask if spatial-pooling can usefully be applied in a gentler manner. If pooling was to only reduce the size of the hidden layers by a factor of , then we could use twice as many layers of pooling. Each layer of pooling is an opportunity to view the input image at a different scale. Viewing images at the ‘right’ scale should make it easier to recognize the tell-tale features that identify an object as belonging to a particular class.
The focus of this paper is thus a particular form of max-pooling that we call fractional max-pooling (FMP). The idea of FMP is to reduce the spatial size of the image by a factor of with . Like stochastic pooling, FMP introduces a degree of randomness to the pooling process. However, unlike stochastic-pooling, the randomness is related to the choice of pooling regions, not the way pooling is performed inside each of the pooling regions.
In Section 2 we give a formal description of fractional max-pooling. Briefly, there are three choices that affect the way FMP is implemented:
The pooling fraction which determines the ratio between the spatial sizes of the input and the output of the pooling layer. Regular max-pooling corresponds to the special case .
The pooling regions can either be chosen in a random or a pseudorandom fashion. There seems to be a trade off between the use of randomness in FMP and the use of dropout and/or training data augmentation. Random-FMP seems to work better on its own; however, when combined with ‘too much’ dropout or training data augmentation, underfitting can occur.
The pooling regions can be either disjoint or overlapping. Disjoint regions are easier to picture, but we find that overlapping regions work better.
In Section 3 we describe how our convolutional networks were designed and trained. In Section 4 we give results for the MNIST digits, the CIFAR-10 and CIFAR-100 datasets of small pictures, handwritten Assamese characters and the CASIA-OLHWDB1.1 dataset of handwritten Chinese characters.
Each convolutional filter of a CNN produces a matrix of hidden variables. The size of this matrix is often reduced using some form of pooling. Max-pooling is a procedure that takes an input matrix and returns a smaller output matrix, say . This is achieved by dividing the square into pooling regions :
and then setting
For regular max-pooling, and . In , max-pooling is applied with overlapping pooling regions so and the are squares, tiled with stride 2. In both cases, so the spatial size of any interesting features in the input image halve in size with each pooling layer. In contrast, if we take then the rate of decay of the spatial size of interesting features is times slower. For clarity we will now focus on the case as we are primarily interested in accuracy; if speed is an overbearing concern then FMP could be applied with .
Given a particular pair of values we need a way to choose pooling regions . We will consider two type of arrangements, overlapping squares and disjoint collections of rectangles. In Figure 1 we show a number of different ways of dividing up a square grid into disjoint rectangles. Pictures two, three and six in Figure 1 can also be used to define an arrangement of overlapping squares: take the top left hand corner of each rectangle in the picture to be the top left hand corner of one of the squares.
To give a formal description of how to generate pooling regions, let and be two increasing sequence of integers starting at 1, ending with , and with increments all equal to one or two (i.e. ). The regions can then be defined by either
We call the two cases disjoint and overlapping, respectively. We have tried two different approaches for generating the integer sequence: using random sequences of numbers and also using pseudorandom sequences.
We will say that the sequences are random if the increments are obtained by taking a random permutation of an appropriate number of ones and twos. We will say that the sequences are pseudorandom if they take the form
Below are some patterns of increments corresponding to the case , . The increments on the left were generated ‘randomly’, and the increments on the right come from pseudorandom sequences:
Although both types of sequences are irregular, the pseudorandom sequences generate much more stable pooling regions than the random ones. To show the effect of randomizing the pooling regions, see Figure 2. We have taken a picture, and we have iteratively used disjoint random pooling regions to reduce the size of the image (taking averages in each pooling region). The result is that the scaled down images show elastic distortion. In contrast, if we use pseudorandom pooling regions, the resulting image is simply a faithfully scaled down version of the original.
The networks are trainined using an implementation of a sparse convolutional network . What this means in practice is that we can specify a convolutional network in terms of a sequence of layers, e.g.
The spatial size of the input layer is obtained by working from right to left: each C2 convolution increases the spatial size by one, and FMP layers increase the spatial size by a factor of , rounded to the nearest integer; see Figure 3
. The input layer will typically be larger than the input images—padding with zeros is automatically added as needed. Fractional max-pooling could also easily be implemented for regular convolutional neural network software packages.
For simplicity, all the networks we use have a linearly increasing number of filters per convolutional layer. We can therefore describe the above network using the shorthand form
indicates that the number of filters in the -th convolutional layer is
, and the subscript 3 indicates three pairs of alternating C2/FMP layers. When we use dropout, we use an increasing amount of dropout the deeper we go into the network; we apply 0% dropout in the first hidden layer, and increase linearly to 50% dropout in the final hidden layer. We use leaky rectified linear units.
Each time we apply an FMP network, either for training or testing purposes, we use different random or pseudorandom sequences to generate the pooling regions. An FMP network can therefore be thought of as an ensemble of similar networks, with each different pooling-region configuration defining a different member of the ensemble. This is similar to dropout 
; the different values the dropout mask can take define an ensemble of related networks. As with dropout, model averaging for FMP networks can help improve performance. If you classify the same test image a number of times, you may get a number of different predictions. Using majority voting after classifying each test image a number of times can substantially improve accuracy; see Figure4.
To compare the different kinds of fractional max-pooling, we trained FMP networks on the MNIST111http://yann.lecun.com/exdb/mnist/ set of digits and the CIFAR-100 dataset of small pictures . For MNIST we used a small FMP network:
and for CIFAR-100 we used a larger network:
Without using training data augmentation, state-of-the-art test errors for these two datasets are 0.39% and 34.57%, respectively . Results for the FMP networks are in Table 1. Using model averaging with multiplicity twelve, we find that random overlapping FMP does best for both datasets. For CIFAR-100, the improvement over method using regular max-pooling is quite substantial.
To give an idea about network complexity, the CIFAR-100 networks have 12 million weights, and were trained for 250 repetitions of the training data (18 hours on a GeForce GTX 780). We experimented with changing the number of hidden units per layer for CIFAR-100 with random overlapping pooling:
Using ‘’ (0.8M weights) gave test errors of 42.07% / 34.87%.
Using ‘’ (3.2M weights) gave test errors of 35.09% / 29.66%.
Using ‘’ (27M weights) combined with dropout and a slower rate of learning rate decay gave test errors of 27.62% / 23.82%.
|Dataset and the number||pseudorandom||random||pseudorandom||random|
|of repeat tests||disjoint||disjoint||overlapping||overlapping|
|MNIST, 1 test||0.54||0.57||0.44||0.50|
|MNIST, 12 tests||0.38||0.37||0.34||0.32|
|CIFAR-100, 1 test||31.67||32.06||31.2||31.45|
|CIFAR-100, 12 tests||28.48||27.89||28.16||26.39|
To compare the effect of training data augmentation when using FMP pooling versus MP2 pooling, we used the The Online Handwritten Assamese Characters Dataset . It contains 45 samples for each of 183 Indo-Aryan characters. ‘Online’ means that each pen stroke is represented as a sequence of coordinates. We used the first 36 handwriting samples as the training set, and the remaining 9 samples for a test set. The characters were scaled to fit in a box of size . We trained a network with six layers of max pooling,
and an FMP network using 10 layers of random overlapping FMP pooling,
We trained the networks without dropout, and either
no training data augmentation,
with the characters shifted by adding random translations, or
with affine transformations, using a randomized mix of translations, rotations, stretching, and shearing operations.
See Table 2. In a sense, max-pooling and training data augmentation are two different ways of encoding our apriori knowledge that the meaning of handwriting is generally invariant under certain kinds of minor distortions. Interestingly, the FMP network without data augmentation does better than the MP2 network with training data augmentation, suggesting that FMP is a better way of encoding that information.
|6 layers of MP2||14.1||4.6||1.8|
|10 layers of FMP(, 1 test||1.9||1.3||0.9|
|10 layers of FMP(, 12 tests||0.7||0.8||0.4|
The CASIA-OLHWDB1.1 database contains online handwriting samples of the 3755 isolated GBK level-1 Chinese characters . There are approximately 240 training characters, and 60 test characters, per class. A test error of 5.61% is achieved using 4 levels of MP2 pooling .
We used the representation for online characters described in ; the characters were drawn with size and additional features measuring the direction of the pen are added to produce an array of size . Using 6 layers of max-pooling, dropout and affine training data augmentation resulted in a 3.82% test error . Replacing max-pooling with pseudorandom overlapping FMP:
results in test errors of 3.26% (1 test) and 2.97% (12 tests).
For CIFAR-10 we used dropout and extended the training set using affine transformations: a randomized mix of translations, rotations, reflections, stretching, and shearing operations. We also added random shifts to the pictures in RGB colorspace. For a final 10 training epochs, we trained the network without the affine transformations.
For comparison, human performance on CIFAR-10 is estimated to be 6%222http://karpathy.ca/myblog/?p=160. A recent Kaggle competition relating to CIFAR-10 was won with a test error of 4.47%333https://www.kaggle.com/c/cifar-10/ using the same training data augmentation scheme, and architecture
Using a pseudorandom overlapping pooling FMP network
we obtained test errors of 4.50% (1 test), 3.67% (12 tests) and 3.47% (100 tests).
We have trained convolutional networks with fractional max-pooling on a number of popular datasets and found substantial improvements in performance. Overlapping FMP seems to be better than disjoint FMP. Pseudorandom pooling regions seem to do better than random pooling regions when training data augmentation is used. It is possible that random pooling might regain the upperhand if we fine-tuned the amount of dropout used.
Looking again at the distortions created by random pooling in Figure 2, note that the distortion is ‘decomposable’ into an -axis distortion and a -axis distortion. It might be interesting to explore pooling regions that cannot be written using equation 1, as they might encode more general kinds of distortion into the resulting convolutional networks.
UCI machine learning repository, 2013.