Convolutional Neural Networks for Page Segmentation of Historical Document Images

TL;DR

This paper introduces a simple CNN-based approach for segmenting handwritten historical document images, treating page segmentation as pixel classification, and demonstrates its competitive performance against more complex models.

Contribution

Proposes a straightforward CNN architecture for page segmentation that learns features directly from raw pixels, outperforming traditional handcrafted feature methods.

Findings

Simple CNN achieves competitive results on public datasets.

Method outperforms previous traditional approaches.

Effective pixel labeling for historical document images.

Abstract

This paper presents a Convolutional Neural Network (CNN) based page segmentation method for handwritten historical document images. We consider page segmentation as a pixel labeling problem, i.e., each pixel is classified as one of the predefined classes. Traditional methods in this area rely on carefully hand-crafted features or large amounts of prior knowledge. In contrast, we propose to learn features from raw image pixels using a CNN. While many researchers focus on developing deep CNN architectures to solve different problems, we train a simple CNN with only one convolution layer. We show that the simple architecture achieves competitive results against other deep architectures on different public datasets. Experiments also demonstrate the effectiveness and superiority of the proposed method compared to previous methods.

Tables

Table 1. Table I: Details of training, test, and validation sets. T ​ R 𝑇 𝑅 TR , T ​ E 𝑇 𝐸 TE , and V ​ A 𝑉 𝐴 VA denotes the training, test, and validation sets respectively.

	image size (pixels)	$\left|TR\right|$	$\left|TE\right|$	$\left|VA\right|$
G. Washington	$2200\times 3400$	10	5	4
St. Gall	$1664\times 2496$	20	30	10
Parzival	$2000\times 3008$	20	13	2
CB55	$4872\times 6496$	20	10	10
CSG18	$3328\times 4992$	20	10	10
CSG863	$3328\times 4992$	20	10	10

Table 2. Table II: Performance (in percentage) of superpixel labeling with only local MLP, CRF, and the proposed CNN.

	G. Washington				Parzival				St.Gall
	pixel	mean	mean	f.w.	pixel	mean	mean	f.w.	pixel	mean	mean	f.w.
	acc.	acc.	IU	IU	acc.	acc.	IU	IU	acc.	acc.	IU	IU
Local MLP [17]	87	89	75	83	91	64	58	86	95	89	84	92
CRF [18]	91	90	76	85	93	70	63	88	97	88	84	94
CNN	91	91	77	86	94	75	68	89	98	90	87	96
CNN (max pooling)	91	90	77	86	94	75	68	89	98	90	87	96
	CB55				CSG18				CSG863
	pixel	mean	mean	f.w.	pixel	mean	mean	f.w.	pixel	mean	mean	f.w.
	acc.	acc.	IU	IU	acc.	acc.	IU	IU	acc.	acc.	IU	IU
Local MLP [17]	83	53	42	72	83	49	39	73	84	54	42	74
CRF [18]	84	53	42	75	86	47	37	77	86	51	42	78
CNN	86	59	47	77	87	53	41	79	87	58	45	79
CNN (max pooling)	86	60	48	77	87	53	42	80	87	57	45	79

Equations

$$P(y=i|x,W_1,\cdots ,W_M,b_1,\cdots ,b_M)=\frac{e^{W_{i}x+b_i}}{{\sum }_{j=1}^M{e}^{W_{j}x+b_j}},$$

$$\hat{y}=\underset{i}{\mathrm{argmax}}P(y=i|x,W_1,\cdots ,W_M,b_1,\cdots ,b_M).$$

$$f(x)=\max (0,x),$$

$$\mathcal{L}(X,Y)=-\frac{1}{n}\sum _{i=1}^n(\ln a(x^{(i)})+(1-y^{(i)})\ln (1-a(x^{(i)}))),$$

$$t_i=\sum _j{n}_{ji}.$$

$$acc=\frac{{\sum }_i{n}_{ii}}{{\sum }_i{t}_i}.$$

$$ac{c}_{mean}=\frac{1}{n_c}\times \sum _i\frac{n_{ii}}{t_i}.$$

$$i{u}_{mean}=\frac{1}{n_c}\times \sum _i\frac{n_{ii}}{t_i+{\sum }_j{n}_{ji}-n_{ii}}.$$

$$i{u}_{weighted}=\frac{1}{{\sum }_k{t}_k}\times \sum _i\frac{t_i\times n_{ii}}{t_i+{\sum }_j{n}_{ji}-n_{ii}}.$$

Full text

I Introduction

Page segmentation is an important prerequisite step of document image analysis and understanding. The goal is to split a document image into regions of interest. Compared to segmentation of machine printed document images, page segmentation of historical document images is more challenging due to many variations such as layout structure, decoration, writing style, and degradation. Our goal is to develop a generic segmentation method for handwritten historical document images. In this method, we consider the segmentation problem as a pixel-labeling problem, i.e., for a given document image, each pixel is labeled as one of the predefined classes.

Some page segmentation methods have been developed recently. These methods rely on hand-crafted features [1, 2, 3, 4] or prior knowledge [5, 6, 7, 8], or models that combine hand-crafted features with domain knowledge [9, 10]. In contrast, in this paper, our goal is to develop a more general method which automatically learns features from the pixels of document images. Elements such as strokes of words, words in sentences, sentences in paragraphs have a hierarchical structure from low to high levels. As these patterns are repeated in different parts of the documents. Based on these properties, feature learning algorithms can be applied to learn layout information of the document images.

Convolutional Neural Network (CNN) is a kind of feed-forward artificial neural network which shares weights among neurons in the same layer. By enforcing local connectivity pattern between neurons of adjacent layers, CNN can discover spatially local correlation [11]. With multiple convolutional layers and pooling layers, CNN has achieved many successes in various fields, e.g., handwriting recognition [12], image classification [13], text recognition in natural images [14], and sentence classification [15].

In our previous work [16], an autoencoder to learn features automatically on the training images. An autoencoder is a feed forward neural network. The main idea is that by training an autoencoder to reconstruct its input, features can be discovered on the hidden layers. Then an off-the-shelf classifier can be trained with the learned features to predict pixels into different predefined classes. By using superpixels as the units of labeling [17], the speed of the method is increased. In [18], a Conditional Random Field (CRF) [19] is applied in order to model the local and contextual information jointly to refine the segmentation results which have been achieved in [17]. Following the same idea of [18], we consider the segmentation problem as an image patch labeling problem. The image patches are generated by using superpixels algorithm. In contrast to [16, 17, 18], in this work, we focus on developing an end-to-end method. We combine feature learning and classifier training into one step. Image patches are used as input to train a CNN for the labeling task. During training, the features used to predict labels of the image patches are learned on the convolution layers of the CNN.

While many researchers focus on developing very deep CNN to solving various problems [13, 20, 21, 22, 23], in the proposed method, we train a simple CNN of one convolution layer. Experiments on public historical document image datasets show that despite the simple structure and little tuning of hyperparameters, the proposed method achieves comparable results compared to other CNN architectures.

The rest of the paper is organized as follows. Section II gives an overview of some related work. Section III presents the proposed CNN for the segmentation task. Section IV reports the experimental results and Section V presents the conclusion.

II Related Work

This section reviews some representative state-of-the-art methods for historical document image segmentation. Unlike segmentation of contemporary machine printed documents, segmentation of handwritten historical documents is more challenging due to the various writing styles, the rich decoration, degradation, noise, and unrestricted layout. Therefore, traditional page segmentation method can not be applied to handwritten historical documents directly. Many methods have been proposed for segmentation of handwritten historical documents, which largely can be divided into rule based and machine learning based.

Some methods rely on threshold values predefined based on prior knowledge of the document structure. Van Phan et al. [6] use the area of Voronoi diagram to represent the neighborhood and boundary of connected components (CCs). By applying predefined rules, characters were extracted by grouping adjacent Voronoi regions. Panichkriangkrai et al. [7] propose a text line and character extraction system of Japanese historical woodblock printed books. Text lines are separated by using vertical projection on binarized images. To extract kanji characters, rule-based integration is applied to merge or split the CCs. Gatos et al. [8] propose a text zone and text line segmentation method for handwritten historical documents. Based on the prior knowledge of the structure of the documents, vertical text zones are detected by analyzing vertical rule lines and vertical white runs of the document image. On the detected text zones, a Hough transform based text line segmentation method is used to segment text lines. All these methods have achieved good segmentation results on specific document datasets. However, the common limitation is that a set of rules have to be carefully defined and document structure is assumed to be observed. Benefit from the prior knowledge of the structure, the thresholds values are tuned in order to archive good performance. In other words, due to the generality, the rule-based methods can not be applied to other kinds of historical document images directly.

In order to increase the generality and robustness of page segmentation methods, machine learning techniques are employed. In this case, usually the segmentation problem is considered as a pixel labeling problem. Feature representation is the key of the machine learning based methods. Carefully hand-crafted features are designed in order to train an off-the-shelf classifier on the labeled training set. Bukhari et al. [2] propose a text segmentation method of Arabic historical document images. They consider the normalized height, foreground area, relative distance, orientation, and neighborhood information of the CCs as features. Then the features are used to train a multilayer perceptron (MLP). Finally, the trained MLP is used to classify CCs to relevant classes of text. Cohen et al. [9] apply Laplacian of Gaussian on the multi-scale binarized image to extract CCs. Based on prior knowledge, appropriate threshold values are chosen in order to remove noise CCs. With an energy minimization method and the features, such as bounding box size, area, stroke width, and estimated text lines distance, each CC is labeled into text or non-text. Asi et al. [10] propose a two-steps segmentation method of Arabic historical document images. They first extract the main text area with Gabor filters. Then the segmentation is refined by minimization an energy function. Compared to the rule based methods, the advantage of the machine learning based methods is less prior knowledge is needed. However, the existing machine learning based methods rely on hand-crafted feature engineering and to obtain appropriate hand-crafted features for specific tasks is cumbersome.

III Methodology

In order to create general page segmentation method without using any prior knowledge of the layout structure of the documents, we consider the page segmentation problem as a pixel labeling problem. We propose to use a CNN for the pixel labeling task. The main idea is to learn a set of feature detectors and train a nonlinear classifier on the features extracted by the feature detectors. With the set of feature detectors and the classifier, pixels on the unseen document images can be classified into different classes.

III-A Preprocessing

In order to speed up the pixel labeling process, for a given document image, we first applying a superpixel algorithm to generate superpixels. A superpixel is an image patch which contains the pixels belong to the same object. Then instead of labeling all the pixels, we only label the center pixel of each superpixel and the rest pixels in that superpixel are assigned to the same label. The superiority of the superpixel labeling approach over the pixel labeling approach for the page segmentation task has been demonstrated in [17]. Based on the previous work [17], the simple linear iterative clustering (SLIC) algorithm is applied as a preprocessing step to generate superpixels for given document images.

III-B CNN Architecture

The architecture of our CNN is given in Figure 1. The structure can be summarized as $28\times 28\times 1-26\times 26\times 4-100-M$, where $M$ is the number of classes. The input is a grayscale image patch. The size of the image patch is $28\times 28$ pixels. Our CNN architecture contains only one convolution layer which consists of $4$ kernels. The size of each kernel is $3\times 3$ pixels. Unlike other traditional CNN architecture, the pooling layer is not used in our architecture. Then one fully connected layer of $100$ neurons follows the convolution layer. The last layer consists of a logistic regression with softmax which outputs the probability of each class, such that

[TABLE]

where $x$ is the output of the fully connected layer, $W_{i}$ and $b_{i}$ are the weights and biases of the $i^{th}$ neuron in this layer, and $M$ is the number of the classes. The predicted class $\hat{y}$ is the class which has the max probability, such that

[TABLE]

In the convolution and fully connected layers of the CNN, Rectified Linear Units (ReLUs) [24] are used as neurons. An ReLU is given as:

[TABLE]

where $x$ is the input of the neuron. The superiority of using ReLUs as neurons in CNN over traditional sigmoid neurons is demonstrated in [13].

III-C Training

To train the CNN, for each superpixel, we generate a patch which is centred on that superpixel. The patch is considered as the input of the network. The size of each patch is $28\times 28$ pixels. The label of each patch is its center pixel’s label. The patches of the training images are used to train the network.

In the CNN, the cost function is defined as the cross-entropy loss, such that

[TABLE]

where $X=\{x^{(1)},\cdots,x^{(n)}\}$ is the training image patches and $Y=\{y^{(1)},\cdots,y^{(n)}\}$ is the corresponding set of labels. The number of training image patches is $n$. For each $x^{(i)}$, $a(x^{(i)})$ is the output of the CNN as defined in Eq. 1. The CNN is trained with Stochastic Gradient Descent (SGD) with the dropout [25] technique. The goal of dropout is to avoid overfitting by introducing random noise to training samples. Such that during the training, the outputs of the neurons are masked out with the probability of $0.5$.

IV Experiment

Experiments on six public handwritten historical document image datasets are conducted.

IV-A Datasets

The datasets are of very different nature. The G. Washington dataset consists of the pages written in English with ink on paper and the images are in gray levels. The other two datasets, i.e., Parzival and St. Gall datasets consist of images of manuscripts written with ink on parchment and the images are in color. The Parzival dataset consits of the pages written by three writers in the $13$th century. The St. Gall dataset consists the manuscripts from a medieval manuscript written in Latin. The details of the ground truth are presented in [26].

Three new datasets with more complex layout have been recently created [27]. The CB55 dataset consists of manuscripts from the $14$th century which are written in Italian and Latin languages by one writer. The CSG18 and CSG863 datasets consist of manuscripts from the $11$th century which are written in Latin language. The number of the writers of the two datasets is not specified. The details of the three datasets are presented in [27].

In the experiments, all images are scaled down with a scaling factor $2^{-3}$. Table I gives the details of training, test, and validation sets of the six datasets.

IV-B Metrics

To evaluate methods of page segmentation for historical document images, the most used metrics are precision, recall, and pixel level accuracy. In contrast, besides of the standard metrics, we adapt the metrics which are well defined and has been widely used from common semantic segmentation and scene parsing evaluations. The metrics are variations on pixel accuracy and region intersection over union (IU). They have been proposed in [28]. Consequently, the metrics used in the experiments are: pixel accuracy, mean pixel accuracy, mean IU, and frequency weighted IU (f.w. IU).

In order to obtained the metrics, we define the variables:

• •

$n_{c}$: the number of classes.

• •

$n_{ij}$: the number of pixels of class $i$ predicted to belong to class $j$. For class $i$:

• –

$n_{ii}$: the number of correctly classified pixels (true positives).

• –

$n_{ij}$: the number of wrongly classified pixels (false positives).

• –

$n_{ji}$: the number of wrongly not classified pixels (false negatives).

• •

$t_{i}$: the total number of pixels in class $i$, such that

[TABLE]

With the defined variables, we can compute:

• •

pixel accuracy:

[TABLE]

• •

mean accuracy:

[TABLE]

• •

mean IU:

[TABLE]

• •

f.w. IU:

[TABLE]

IV-C Evaluation

We compare the proposed method to our previous methods [17, 18]. Similar to the proposed method, superpixels are considered as the basic unit of labeling. In [17], the features are learned on randomly selected grayscale image patches with a stacked convolutional autoencoder in an unsupervised manner. Then the features and the labels of the superpixels are used to train a classifier. With the trained classifier, superpixels are classified into different classes. In [18], a Conditional Random Field (CRF) is applied in order to model the local and contextual information jointly for the superpixel labeling task. The trained classifier in [17] is considered as the local classifier in [18]. Then the local classifier is used to train a contextual classifier which takes the output of the local classifier as input and output the scores of given labels. With the local and contextual classifiers, a CRF is trained to label the superpixels of a given image. In the experiments, we use a multilayer perceptron (MLP) as the local classifier in [17, 18] and another MLP as the contextual classifier in [18]. Simple Linear Iterative Clustering algorithm (SLIC) [29] is applied to generate the superpixels. The superiority of SLIC over other superpixel algorithms is demonstrated in [17]. In the experiments, for each image, $3000$ superpixels are generated.

Table II reports the pixel accuracy, mean pixel accuracy, mean IU, and f.w. IU of the three methods. It is shown that the proposed CNN outperforms the previous method. Figure 2 gives the segmentation results of the three methods. We can see that visually the CNN achieve more accurate segmentation results compared to other methods.

IV-D Max Pooling

Pooling is a widely used technology in CNN. Max pooling is the most common type of pooling which is applied in order to reduce spatial size of the representation to reduce the number of parameters of the network. In order to show the impact of max pooling for the segmentation task. We add a max pooling layer after the convolution layer. The pooling size is $2\times 2$ pixels. Table II reports the performance of the CNN with a max pooling layer. We can see that only on the CB55 dataset, the mean pixel accuracy and mean IU are slightly improved. In general, adding a max pooling layer does not improve the performance of the segmentation task. The reason is that for some computer vision problems, e.g., object recognition and text extraction in natural images, the exact location of a feature is less important than its rough location relative to other features. However, for a given document image, to label a pixel in the center of a patch, it is not sufficient to know if there is text somewhere in that patch, but also the location of the text. Therefore, the exact location of a feature is helpful for the page segmentation task.

IV-E Number of Kernels

In order to show the impact of the number of kernels of the convolution layer on the segmentation task. We define the number of kernels as $K$. In the experiments, we set $K\in\{1,2,4,6,8,10,12,14\}$. Figure 3 reports the f.w. IU of the one convolution layer CNN with different number of kernels. We can see that except on the CS18 dataset, when $K\geq 4$ the performance is not improved.

IV-F Number of Layers

In order to show the impact of the number of convolutional layers on the page segmentation task. We incrementally add convolutional layers, such that there is two more kernels on the current layer than the previous layer. Figure 4 reports the f.w. IU of the CNN with different number of convolutional layers. It is show that the number of layers does not affect the performance of the segmentation task. However, on the G. Washington dataset, with more layers, the performance is degraded slightly. The reason is that compared to other datasets, the G. Washington dataset has fewer training images.

IV-G Number of Training Images

In order to show the performance under different amount of training images. For each dataset, we choose $N$ images in the training set to train the CNN. For each experiment, the number of batches is set to $5000$. Figure 5 reports the f.w. IU under different values of $N$, such that $N\in\{1,2,4,8,10,12,14,16,18,20\}$111In the G. Washington dataset, there is $10$ training images. Therefore, $N\in\{1,2,4,8,10\}$. We can see that in general, when $N>2$, the performance is not improved. However, on the G. Washington dataset, with more training images, the performance is degraded slightly. The reason is that compared to the other datasets, on the G. Washington dataset the pages are more varied and the ground truth is less constant.

IV-H Run Time

The proposed CNN is implemented with the python library Theano [30]. The experiments are performed on a PC with an Intel Core i7-3770 3.4 GHz processor and 16 GB RAM. On average, for each image, the CNN takes about $1$ second processing time. The superpixel labeling method [17] and CRF model [18] take about $2$ and $5$ seconds respectively.

V Conclusion

In this paper, we have proposed a convolutional neural network (CNN) for page segmentation of handwritten historical document images. In contrast to traditional page segmentation methods which rely on off-the-shelf classifiers trained with hand-crafted features, the proposed method learns features directly from image patches. Furthermore, feature learning and classifier training are combined into one step. Experiments on public datasets show the superiority of the proposed method over previous methods. While many researchers focus on applying very deep CNN architectures for different tasks, we show that with the simple one convolution layer CNN, we achieve comparable performance compared to other network architectures.