PCA-Initialized Deep Neural Networks Applied To Document Image Analysis

TL;DR

This paper introduces a PCA-based initialization method for deep neural networks, transforming PCA into auto-encoders, which improves stability and performance in document layout analysis compared to traditional random initialization.

Contribution

The paper presents a novel PCA-based initialization technique for neural networks, turning PCA into auto-encoders, and demonstrates its effectiveness in document image analysis tasks.

Findings

PCA-based initialization is quick and stable.

It outperforms random weight initialization in layout analysis.

The method enhances training efficiency and accuracy.

Abstract

In this paper, we present a novel approach for initializing deep neural networks, i.e., by turning PCA into neural layers. Usually, the initialization of the weights of a deep neural network is done in one of the three following ways: 1) with random values, 2) layer-wise, usually as Deep Belief Network or as auto-encoder, and 3) re-use of layers from another network (transfer learning). Therefore, typically, many training epochs are needed before meaningful weights are learned, or a rather similar dataset is required for seeding a fine-tuning of transfer learning. In this paper, we describe how to turn a PCA into an auto-encoder, by generating an encoder layer of the PCA parameters and furthermore adding a decoding layer. We analyze the initialization technique on real documents. First, we show that a PCA-based initialization is quick and leads to a very stable initialization. Furthermore, for the task of layout analysis we investigate the effectiveness of PCA-based initialization and show that it outperforms state-of-the-art random weight initialization methods.

Equations

$${\vec{y}}_{nn}=f\left(\vec{b}+W\cdot \vec{x}\right)$$

$${\vec{y}}_{pca}=R\cdot \left(\vec{x}-\vec{m}\right)=R\cdot \vec{x}-R\cdot \vec{m}$$

$${\vec{y}}_{apca}=f\left(R\cdot \vec{x}-R\cdot \vec{m}\right)$$

$$f\left(R\cdot \vec{0}-R\cdot \vec{m}\right)=f\left(\vec{b}+W\cdot \vec{0}\right)$$

$$f\left(R\cdot \vec{x}+\vec{b}\right)=f\left(\vec{b}+W\cdot \vec{x}\right)$$

$$\vec{x}\approx f\left({\vec{b}}_2+W_2\cdot f\left({\vec{b}}_1+W_1\cdot \vec{x}\right)\right)$$

$$Y=f\left(W_1^{+}\cdot X^{+}\right)$$

$$X\approx f\left(W_2^{+}\cdot Y\right)$$

$$\vec{x}=R^{-1}\cdot R\cdot \left(\vec{x}-\vec{m}\right)+\vec{m}$$

$$r_{be}\left(n\right)=\frac{{\sum }_i\left|e_{n,in,i}\right|}{{\sum }_i\left|e_{n,out,i}\right|}$$

Full text

I Introduction

A recent trend in machine learning is training very deep neural networks. Although artificial neurons have been around for a long time, the depth of commonly used artificial neural networks has started to increase significantly only for roughly 15 years [9]111Note that deep neural architectures where proposed already much earlier, but they have not been heavily used in practice [16]. This is due to both a combination of higher computational power available to researchers, and to a coming back of layer-wise training methods [2] (referred to as Deep Belief Networks [10], and often composed of Restricted Boltzmann Machines [18]).

However, the training of deep neural networks still suffers from two major drawbacks. First, training a Deep Neural Network (Dnn) still takes some time, and second, initializing the weights of Dnn with random values adds some randomness to the obtained results.

Especially for large input images or patches with diverse content, the training time becomes a crucial issue, as many weights have to be trained and a training epoch takes much time. Historical Document Image Analysis (Dia) is en example for such tasks as input documents could be of several megabytes and the historical documents can be quite diverse. The diversity has several origins: degradations present in the documents, complexity and variability of the layouts, overlapping of contents, writing styles, bleed-through, etc.

In this paper, we present a novel initialization method based on the Pca which allows to quickly initialize the weights of a neural network with non-random values, and additionally leads to a high similarity in the weights of two networks initialized on different random samples from a same dataset.

II State of the Art

There are currently three main trends for neural network initialization: 1) random initial initial weights [8], layer-wise unsupervised pre-training [2, 10], or transfer learning [3].

Random initialization is fast and simple to implement. The most used one, presented by Glorot et al. recommend [8] to initialize weights of a neuron in $\left[-\sqrt{N},\sqrt{N}\right]$, where $N$ is the number of inputs of the neuron. This initialization is often called “Xavier” initialization, motivated by the first author’s name in [8].

The link between Pca and neural networks is not novel. In 1982, Oja introduced a linear neuron model learning to generate the principal component of its input data [13]. Oja also later investigated the possibility of having linear neural layers learn principal and minor components of a Pca [14]. Since then, other publication present methods teaching networks to compute Pca. Pca is also used for dimensionality reduction as a pre-processing steps [12, 19]. Chan et al. showed that Pca filters can be convolved and stacked in order to create efficient feature extractors [4].

Note that while we were conducting our experiments (published in a Master thesis [1]) a similar, but independent, research has been published at ICLR 2016 [11]. While the general initial idea of using Pca for initialization is similar, it is applied to Convolutional Neural Network (Cnn) in [11]. In this work, we introduce a mathematical framework for generating Convolutional Auto-Encoder (Cae) out of the Pca, taking into account the bias of neural layers, and provide a deeper analysis of the behavior of Pca-initialized networks – both for Cae and Cnn – with a focus on historical document images.

III PCA as Auto-Encoder

An Auto-Encoder (Ae) is a machine learning method which is trained to encode its input as a (usually) compressed representation, and decode this representation to recover the input with an accuracy as good as possible. This compressed representation, also called feature vector, contains a representation of the input of the Ae and can be used for classification purpose. A Dnn can be trained by stacking Aes, as the layers can be trained one after another, without time-consuming back-propagation through all layers.

III-A Encoder Computation

A standard artificial neural layer takes as input a vector $\vec{x}$, multiplies it by a weight matrix $W$, adds a bias vector $\vec{b}$, and applies a non-linear activation function $f$ to the result to obtain the output $\vec{y}$:

[TABLE]

An Ae is usually composed of two neural layers, one which is trained to encode, and the second to decode. The weights of these layers can have a relationship (e.g., in Restricted Boltzmann Machines, the matrix of the decoder is the transpose of the matrix of the encoder), but this is not mandatory.

A Pca is computed by subtracting the mean vector from the data $\vec{m}$ to an input vector $\vec{x}$, and multiplying the result by a matrix $R$ to obtain the result $y$:

[TABLE]

In order to have a neural layer having a similar behavior as the Pca, we have to also apply the activation function $f$ to the Pca, and thus obtain what we call activated Pca:

[TABLE]

We want that $\vec{y}_{apca}=\vec{y}_{nn}$. Let $\vec{x}_{0}=\vec{0}$. Then, we have

[TABLE]

Assuming that $f$ is strictly monotonous, we get that $\vec{b}=-R\cdot\vec{m}$. We can inject this result in Equation 3 to get

[TABLE]

Thus, we get that $W=R$. This allows us to set the weights and bias of a neural layer such that it behaves exactly as an activated Pca. The additional computational cost for computing $\vec{b}$ is negligible, thus the initialization cost of the network depends only on the number of samples used for computing the Pca.222note that the samples used for Pca can be less than the full training set. We investigate this aspect in the experiments

In order to decrease the dimensionality of the encoded values, only some of the principal components can be kept. For reasons of notation simplicity, we will however ignore this in the formulas. We will also show only the 9 first components in the figures, as having more would make them tiny and harder to analyze.

If the activation function is not strictly monotonous, e.g., as the rectified linear unit, then for each sample the activation probability of each feature is 50%. If $N$ features are used, then $\frac{1}{2^{N}}$ of the samples will not activate any feature. If this is an issue, this can be tackled by duplicating one of the component and multiplying its weights by -1.

III-B Decoder Approximation

In the previous step, we proved that a Pca can be used to initialize the weights of a single neural layer. However, a layer in an Ae is composed of two neural layers: the encoder and the decoder. While Pca-initialized neural layers can be used for generating the encoder, initializing the decoder requires another approach if we want to have two neural layers having the same implementation. Encoding and decoding an input $\vec{x}$ with two layers, having respectively the weights $W_{1}$ and $W_{2}$, and the bias $\vec{b}_{1}$ and $\vec{b}_{2}$ is done as the following:

[TABLE]

However, the reconstruction of $\vec{x}$ cannot be perfect for most activation functions $f$. Thus, we propose to compute $\vec{b}_{2}$ and $W_{2}$ by minimizing the squared error of the reconstruction of at least as many samples as there are dimensions in the Pca.

Let us assume that $X$ is a matrix which columns are composed of at least as many input vectors as components from the Pca have been kept. We can create the matrices $X^{+}$ by appending a row composed of $1$’s to $X$, and $W_{1}^{+}$ by appending a column composed of the vector $\vec{b}_{1}$ to $W_{1}$.

Then, we can compute the matrix $Y$ storing the encoded samples in its columns as

[TABLE]

Then, to compute $\vec{b}_{2}$ and $W_{2}$, we have to find the matrix $W_{2}^{+}$ approximating the following with the smallest square error:

[TABLE]

where $X$ is an input vector filled either with real samples, or random values. In other words, we have to find the least-squares solution to the following equation system: $W_{2}^{+}\cdot Y=f^{-1}\left(X\right)$. The vector $\vec{b}_{2}$ is then the last column of $W_{2}^{+}$, and $W_{2}$ is the other columns of $W_{2}^{+}$.

III-C Differences Between PCA and Aes

The matrix $R$ of a Pca can be inverted, thus we have

[TABLE]

However, in the case of an Ae, the non-linearity prevents from reconstructing perfectly the input. In practice, this leads to having a lower contrast when decoding, as the encoded values, which are unbounded when applying a Pca are restricted to the interval $\left]-1,1\right[$ when applying a Pca-initialized neural layer. This effect is illustrated in Figure 1.

Note that Aes are used for initializing the weights of neural networks, so the decoding layer is not used for classification tasks. Thus, this is not an issue for classification if we get low-contrast reconstructions. However, in order to allow a better visual inspection of the features, we will enhance their contrast in this paper.

IV Impact Evaluation

In this section, we evaluate two aspect of a Pca-based initialization: first, how stable the features are, and second, what the impact of a Pca-based initialization is for classification tasks. All time measurements have been done on a computer with an i5-4570 processor; note that some of the tasks were done too fast for it to increase its frequency.

We used six manuscripts coming from two datasets. The first dataset is composed of pages from the manuscripts SG857333St. Gallen, Stiftsbibliothek, Cod. Sang. 857 (13th century), SG562444St. Gallen, Stiftsbibliothek, Cod. Sang. 562 (9th century), and GW10555G. W. Papers, Library of Congress, (18th century). The layout has been annotated with hand-drawn polygons using Divadia [6]. The different classes are out-of-page, background, text, comments, and annotations. The second dataset is called DIVA-HisDB [17]. It is composed of pages from the manuscripts CB55666Köln, Fondation Bodmer, Cod. Bodm. 55 (14th century), CS18777St. Gallen, Stiftsbibliothek, Cod. Sang. 18 (11th century), and CS863888St. Gallen, Stiftsbibliothek, Cod. Sang. 863. The layout has been annotated using GraphManuscribble [7] using a mix of pen-based interactions and automatic polygon generation.

IV-A Initialization Stability

As we keep only some of the principal components of the data samples used for training, we can expect the features to be stable because they will represent main trends of the data and thus be rather stable with regard to the number of samples used for computing the Pca, or the pages used as sample sources. Features obtained through Pca-initialization of three-levels Aes are shown in Fig. 2. Note that the six Aes used for generating the features of Fig 2 were trained completely independently. Differences between initializations with 500 and 50’000 samples lead to similar features, however the initialization times were very different, with less than 1 second for 500 samples, and $\approx 2100$ seconds for 50’000 samples. Note that due to the differences in training and tests, the results we obtained cannot be compared to our previous works.

Another kind of stability can be observed. If we initialize an Ae on two different pages of a same manuscript, we can expect the features to be similar. While it is not the case when training a network as a standard Ae, we can see in Fig. 2e and 2f that when using a Pca to initialize the Ae the features look very similar. They are not identical, but some patterns are shared. Note that these features are in the third layer; features from the first and second layers, which are not shown for space reason, are almost indistinguishable.

IV-B Feature Activation Map

Visualizing features as shown in Fig. 2 is not necessarily helpful to know where they are active or not. For this reason, we generate heatmaps showing where some features are the most active. We center the Cae on each pixel of the input image, compute its output, and store the activation value of the three first values as the red, green and blue components of the corresponding pixel of the output image. Note that there is no labelled training involved in this task – the Ae are completely unsupervised.

Very good features should have high levels of correlation with the classes to discriminate. We can see in Fig. 3b that the Pca-initialized Ae leads to a smooth representation of its input, with clear distinctions between the main part of the decoration (green), the thin red lines below the decoration (purple), and also hints the text line positions (yellow) and interlines (gray). However, while the Xavier-initialized Ae seems to capture some areas of the main part of the decoration, the feature activation map is more noisy, and the colors seem less correlated to the kind of content, as there is mostly only red, green and blue. The background is however better represented by the Xavier-initialized Ae.

IV-C Classification Task

We evaluate our method for a document image layout analysis task at pixel-level. The goal is to label the pixels of a document image as corresponding to different kinds of content, e.g., background or interlinear glosses. This is a continuation of our previous work [5], with the main difference that instead of extracting features from the central position of each layer and feed them to an Support Vector Machine (Svm), we add a classification layer on top of the Ae and do the backpropagation through the whole network. This is an approach which we have already successfully applied on the manuscripts of the DIVA-HisDB [17].

The datasets which we use are split into three parts: training, test and validation. We used document images from both training and test subsets. However, as one of our goal is to study the accuracy on the test data during the training, a large quantity of tests have had to be done. For this reason, we decided to use the following restrictions: we used only two pages from the training set, and test networks on the labelling of 10’000 pixels from the test set. Also in order to run a fair comparison between Xavier and Pca initializations, we use the same training and test samples for all networks trained on a same manuscript. Thus, differences of accuracy at any point in the training are due only to the initial weights of a network.

The results obtained during the training are shown in Fig. 4. We can see that Pca initialization always outperforms Xavier initialization, although after a long training they converge toward similar results. We can however see that although the initial features obtained by Pca are visually stable, the variance of the accuracy for the two approaches is roughly the same at any point of the training, excepted for the networks trained on CS18 (Fig. 4b) because the Pca-initialized networks finished converging very quickly. This is explained by the fact that small differences in initial conditions can lead to very different results [15], thus although rather similar, the Pca initialization leads to an error entropy similar to a random, i.e., Xavier, initialization.

IV-D Error Backpropagation

We can see in Fig. 4 that Pca-initialized networks converge very quickly. To investigate this, we define and use the Relative Backpropagated Error (Rbe):

[TABLE]

where $n$ is a network, $e_{n,in,i}$ is the error of backpropagated to the $i$-th neuron of the first neural layer of $n$, and $e_{n,out,i}$ is the error of the output layer of $n$ with regard to the expected classification result.

The Rbe is directly linked to how much the weights of a network are modified during a gradient descent. Thus, it can give hints about how fast a network is learning, and can be used to compare two converging networks, larger Rbe indicating larger learning rate per sample. However, the Rbe value alone cannot predict whether a network converges or not – a diverging network could even lead to apparently favorable Rbe. In this paper, all networks are converging correctly, therefore the Rbe is a reliable measurement.

We can see in Fig. 5 that Pca-initialized networks (in purple) always lead to higher Rbe than Xavier-initialized networks. This explains why our approach converges much faster. At the beginning of the training, the Rbe can be up to 25 times larger when using a Pca initialization. After a long training, the Rbe for both approaches seem to converge toward similar values, in a similar fashion as the accuracy does in Fig. 4, but even after 2 million weights adjustments, the Pca initialization still leads to more favorable Rbe. This explains why the Pca-initialized networks always reach a high accuracy earlier than xavier-initialized networks.

V Conclusion and Future work

In this paper, we have investigated a new approach for initializing deep auto-encoders using Pca. This leads to significantly better performances for layout analysis tasks for an initialization time that can be considered as negligible. We also investigated the stability of the features learned by Ae initialized with Pca, and show that very few samples are required for computing the Pca.

As future work, we intend to study the use of Linear Discriminant Analysis (Lda) to initialize deep auto-encoders for various types of classification tasks. We assert that this would not only lead to meaningful initializations, as it is the case with Pca, but also generate weights more useful for classification tasks.

We also hypothesize that a Pca-initialized network would outperform a Xavier-initialized network in case of transfer learning, as its weights would be tuned faster to the new task. This, however, has to be validated on varios scenarios.

Acknowledgment

We would like to thank Kai Chen for feedback he provided during the investigations. The work presented in this paper has been partially supported by the HisDoc III project funded by the Swiss National Science Foundation with the grant number 205120_169618.