# A novel scheme for word-level based offline text-independent writer
identification

Vineet Kumar  Suresh Sundaram

###### Abstract

In this paper, we formulate a novel scheme to identify the authorship of a
document based on handwritten input word images of an individual. Our approach
is text-independent and does not place any restrictions on the size of the
input word images under consideration. To begin with, we adapt the SIFT
algorithm to extract multiple key point regions at various levels of
abstraction (comprising allograph, character or combination of characters).
These key point regions are then passed through a trained CNN network to
generate feature maps corresponding to a convolution layer. However, owing to
the scale corresponding to the SIFT key points, the size of a generated
feature map may differ. As an alleviation to this issue, we propose to
consider the histogram of gradients on each of the generated feature maps,
thereby producing a fixed representation.

Typically, in a CNN, the number of filters of each convolution block increase
depending on the depth of the network. Accordingly, the extraction of
histogram features on each of the convolution feature map increase the
dimension as well as the computational load. To address this aspect, we
propose a entropy-based measure to learn ‘saliency’ values of the feature maps
of a particular CNN layer during the training phase of our algorithm. The
measure, as such is derived from the application of sparse PCA on the
histogram of gradient features.

The efficacy of our system has been demonstrated on two publicly available
databases namely CVL and IAM. We empirically show that the results obtained
are promising when compared with previous works.

###### keywords:

Writer identification , SIFT , CNN , HOG features , SVM , CVL database , IAM
database

[inst1]organization=Department of Electronics and electrical
Engineering,addressline=Indian Institute of Technology Guwahati,
city=Guwahati, postcode=781039, state=Assam, country=India

##  1 Introduction

Biometrics refers to the automatic identification or verification of a person
by utilizing either biological [1] or behavioral [2] features. Under the
purview of behavioral bio metrics, writer identification and verification have
gained popularity as a topic of research in recent times with varied
applications in the field of forensic analysis [3], historical document
analysis [4], [5] and security [6].

Writer identification is related to finding the authorship of a given unknown
document from a set of reference documents stored in the database based on
learned features / descriptors. Depending on the contents of the query and
reference document, the writer identification technique can be divided into
text-dependent or text-independent approaches. In former, the author needs to
reproduce a sample of given text based on which the identity is established.
Signature verification falls under the paradigm of a text-dependent system
[7]. Contrast to this, text-independent approach, on the other hand,
identifies the writer regardless of the handwritten material, as long as
sufficient number of samples are available to extract robust features.

Depending on the handwriting acquisition modality being employed, writer
identification systems can be further divided into two paradigms, namely
offline and online. In the online based approach, spatio-temporal information
(in the form of $x$ and $y$ coordinates) along with other features (such as
pressure, azimuth and inclination) is recorded by the data acquisition system,
which are then subsequently employed to characterize a writer. Contrary to
this, in offline techniques, handwritten data is presented in the form of a
scanned image, following which methodologies are suggested to extract various
allographic features of the image to identify the writer. In this paper, we
will mainly focus our research towards the development of an offline text-
independent writer identification.

Based on the literature of offline text-independent writer identification, the
works can be divided into one of the categories, namely texture, shape and
deep learning-based approach [8]. The systems relying on texture analysis
consider each handwritten input sample as a different texture and accordingly
extract a set of features for description in the frequency or spatial domain
respectively. Said et al. [9] proposed a multi-channel 2-D Gabor filter-based
approach for texture analysis by deriving attributes at different frequencies
and orientations. Bertolini et al. [10] used Local phase quantization (LQP)
[11] features extracted from 2-D short term Fourier transform (STFT) for
writer identification.

Contrary to frequency based methods for the description of texture, spatial
techniques treat handwriting as a combination of edges and contours, with
their statistical distributions being employed for writer description. Djeddi
et al. [12] used run-length features based on the gray level run matrix (GLRM)
to describe the handwriting characteristics. Balacu et al. [13] proposed edge
based attributes namely: edge-hinge, and edge-direction features to ascertain
the individuality of handwriting. Hannadet al. [14] divided the handwriting
image into small fragments upon which a set of features namely Local Binary
Pattern (LBP), Local Ternary Pattern (LTP), and Local Phase Quantization (LPQ)
were extracted for writer identification. Wu et al. [15] employed the SIFT
features and its scale and orientation information from the handwriting
samples to characterize a writer. Likewise, in Faraz et al. [16], the authors
used a combination of SIFT and RootSIFT to construct a set of Gaussian mixture
models namely similarity GMM (SGMM) and Dissimilarity GMM (DGMM). In an
essence, these models aimed at capturing the intra-class similarity and inter-
class dissimilarity between same and different writers of the enrolled
database. Last but not least, we also make a mention of oriented basic image
features [17] that have also been employed for the purpose of writer
identification.

The prominent works on shape-based approach divide the handwriting into a
group of segmented shapes and use the statistical description of their
features to characterize the handwriting. Schomaker et al. [18] constructed a
code-book based on connected-component contours ($CO^{3}$) to describe the
shape of frequently occurring allograph for a set of enrolled writers.
Thereafter, this information is used to generate a histogram, that is specific
for each individual writer. Siddiqi et al. [19] used a combination of shape
and texture features in the form of code-book and curvature to represent the
features of a writer. He et al. [20] proposed a junction detection based
approach for identification, wherein they utilized the information of various
types of junctions created by an author to differentiate against other
writers. Akram et al. [21] used Harris corner detection to extract key points
in the form of junctions and corners from a handwritten image. These keypoints
are then used to construct a codebook based on which writer identification is
performed.

The advancements of machine learning in the recent decade have led to the
prominence of deep learning based methods in the area of computer vision
related applications. Compared to traditional hand crafted features, these
techniques learn data dependent characteristics automatically from the
training samples, thus resulting in higher performance. The pioneering attempt
using deep learning for writer identification was introduced by Fiel et al.
[22]. Here, the authors trained a CNN model from writer samples and extracted
feature from the penultimate layer to construct a feature vector. In other
related works, Xing et.al in [23] proposed a multi-stream CNN network called
DeepWriter, wherein two adjacent segmented writer patches are passed trough
the network and their combined features utilized for identification.
Christlein et.al [24] used a clustering based approach to train the weights of
the convolution network in an unsupervised manner, thereby enabling the system
to learn robust local features. Inspired from the idea of Droupout, Yang et.al
in [25] introduced the concept of Drop Stroke, that randomly removes some of
the strokes from the input image. The resulting modified image along with the
original was used to train the weights of the Convolution network. An
empirical study of the effect of individual convolution layers on the writer
identification rate was performed in the work [26] . Sulaiman et.al in [27]
employed the idea of combining deep and hand-crafted features to represent a
writer descriptor.

Majority of the aforementioned works use page or text-line level data to learn
writer features. However, in applications such as forensic examination, often
a situation arises where a decision needs to be made based on analyzing very
small amount of handwritten text such as words. This task poses a challenge as
the writer-related style information is restricted in contrast to page / text-
line level input. Nonetheless, the prominent work in this direction is [28],
where the authors employ a multi task framework to enhance writer related
information by incorporating attributes learnt in the auxiliary task along
with writer features from the main task. In a subsequent work [29], the same
authors proposed a deep neural network model called Fragnet, that uses a
feature pyramid to extract important writer specific features based on which
identification is made. The recent exploration is that of [30], where the
authors exploit the spatial relationship between the sequence of fragments by
a recurrent neural network (RNN).

##  2 RESEARCH FRAMEWORK

In this paper, we propose a HOG based writer identification system that uses
CNN network to identify a writer using a word image. Our work draws
inspiration from Discriminatively Trained part-Based Models [31] which treats
an object as a collection of multiple segments that are trained separately and
combined to recognize an object. Analogous to that, we treat a word as a
combination of multiple small segments containing information in the form of
patterns. These patterns are trained separately following which they are
combined to get the identity of a writer.

We utilise the SIFT method [32] to generate numerous relevant segments from a
word image. This algorithm uses a multi-scale analysis to extract keypoints at
different levels of abstraction (comprising allograph, character, or
combination of characters). The detected SIFT keypoints is then passed through
a CNN network that is pre-trained on the English alphabets of the EMNIST
dataset.

In the present work, corresponding to each fragment, the output feature map
obtained from the specific convolution layer (selected experimentally) is used
for feature representation 111This is contrary to works wherein the output of
the penultimate layer are used as features.. The size of the feature maps
relative to the selected convolution layer varies depending on the scale at
which the SIFT keypoint patches are extracted. In order to achieve a fixed
dimension representation from the different size feature maps, a Histogram Of
Gradient (HOG) approach is proposed. Such a gradient based representation aids
in preserving the spatial relationship between different regions of a feature
map.

Owing to the fact that each layer in a CNN generates a set of feature maps, we
observe that extraction and saving of the HOG feature vectors corresponding to
each map increases the computational load. To alleviate this issue, we propose
a entropy-based measure to learn ‘saliency’ values of the feature maps of a
particular CNN layer during the training phase of our algorithm. The obtained
saliency values of feature maps of a layer in CNN are then subsequently
employed for combining them to a single representation. This idea, as we shall
see later, brings down the the computational cost without compromising on the
loss of information that can be possibly incurred as a result of combination.

The resulting combined map (after incorporation of saliency values) is used to
generate a HOG based feature vector for each writer, following which scores
are obtained from a SVM classifier. It is worth noting here that the SVM
classifier takes as input, the HOG representation of the combined feature maps
for each of the individual SIFT fragments of a word image and outputs a score.
These are then accumulated across all the fragments of the input word and
employed for establishing the identity of the writer.

Figure 1: Pictorial Overveiw of our proposed system. The blocks enclosed in
dotted lines represent the operations that are performed on each writer
fragments.

Fig.1 summarizes the overview of our proposed algorithm. As a reiteration of
the preceding discussion, the input word image is divided into a number of
fragments of different sizes. Thereafter, on each of these individual
fragments the following set of operation is performed:

  * 1.

Generation of feature maps in each convolution layer of the CNN network.

  * 2.

Combination of feature maps of a layer into a single representation

  * 3.

HOG feature extraction on the combined feature map to get a fixed dimension
description of a fragment.

  * 4.

Generation of scores from a trained SVM.

The SVM scores across fragments are accumulated to get the identity of the
writer.

The rest of the paper is organized as follows. In Section 3 we describe the
process of fragment generation using the SIFT keypoint detector. This is
followed by a detailed discussion of the CNN block used for feature extraction
in Section 4. In Section 5, we provide details of the HOG approach for
obtaining fixed size representation of the feature maps. The methodology
proposed for associating saliency values to each layer of a convolution block
is discussed at length in Section 6. In Section 7 the incorporation of the
saliency values for the generation of a combined feature map is elaborated.

With regards to the experiments, the dataset used for evaluating our algorithm
is presented in Section 8 together with the training and testing protocol. In
Section 9 we evaluate the efficacy of our proposed writer identification
algorithm and compare its performance with other prior works. Finally, we
summarize our paper in section 10.

##  3 Fragment generation step

Locating important features across images is a common task prevalent in
various domains of computer vision. Many deep learning based techniques in the
field of writer identification use dense sampling for extracting multiple
handwriting blocks from a given input sample. However, prior studies [33, 34]
have suggested that all the characters in a handwritten image need not be
equally informative in characterizing a writer. Secondly, dense sampling may
result in important writer features getting split across several windows thus
leading to a loss of information. As a circumvention to this, important
attributes in an image (such as corners) are identified and the region around
them extracted as fragments using a pre-determined window size. As such, these
fragments are more likely to discriminate a writer effectively as compared to
the image patches extracted using dense sampling.

A simple key-point detector such as Harris corner works effectively, when the
overall features of images under consideration are similar (in terms of scale
and orientation). However, in case of a handwritten document, a writer may
create a text that can differ in scale, whereby a fixed sized window may not
be always effective in capturing different sized features. This observation
motivated us to employ the popular scale invariant based interest point
detector (SIFT) for extracting the fragments around each of the key points
detected in the image [15, 16, 35]. The SIFT algorithm is divided into four
stages: In the first stage an input image is broken into a Gaussian pyramid,
the size of image at each successive level of the pyramid (called an octave)
is half of the preceding one. In the second stage, the image at each octave is
used to generate a Difference of Gaussian (DoG) images, by convolving them
with a series of Gaussian filer of different variances. In the third stage,
the difference of Gaussian (DoG) images generated in the above step is used to
detect stable keypoints, following which the location, scale and orientation
of these keypoints are computed. Finally, a fixed dimesional feature
descriptor is constructed to represent the image features using Histogram of
Oriented Gradient (HOG).

In our implementation of the SIFT algorithm, we use the scale and orientation
information of the detected keypoints to extract an image patch around that
location. Some of the keypoints extracted using SIFT algorithm on input word
image is shown with the help of Fig. 2.

Figure 2: Example of keypoint detection using SIFT. (a) segmented Input word
image, (b) detected Keypoint

##  4 CNN feature descriptor

A CNN architecture consists of a combination of several convolution blocks
each having a set of filters, whose number increases progressively as we go
deeper into the network. Each set of filters in a convolution block, extracts
feature from the preceding blocks . These input features are extracted by
convolving the learned filter weights over the preceding input layer, with
each filter sharing its weight across the input. The filter weight is learned
during training stage by tuning it continuously to optimize the loss function.
Convolution operation in a CNN can be mathematically represented as:

$x_{j}^{l}=f(\sum_{i\in M_{j}}x_{i}^{l-1}\times k_{ij}^{l}+b_{j}^{l})$ (1)

Here, $x_{j}^{l}$ represents the $j^{th}$ feature map of layer $l$, $f$
represents the non-linear activation function, $M_{j}$ represents a section of
the input feature map, $k$ represents the convolution filter kernel, $l$
represents the depth of the convolution layer and $b$ represents the bias
term.

Most of the CNN based algorithms in the field of writer identification use
images patches of a fixed predefined size extracted at text-line/ document
level to train a convolution network for classifying writers [22, 36, 23, 27].
In the process of designing these type of writer dependent convolution network
we are faced with the following challenges:

  * 1.

Performance of such a model is dependent on quality of database. To properly
train a convolution network, there must be enough training examples to capture
a variety of writing patterns. Furthermore, the required amount of training
example increases as the model gets bigger.

  * 2.

In a convolution network trained to identify multiple classes adding or
removing a class posses a problem, as, the network needs to be retrained on
the whole dataset.

  * 3.

A writer dependent network is not able to generalize writer feature across
different dataset, as such the performance of the system decreases when the
convolution network trained on a particular dataset is used to test writer
samples form a different dataset [29].

Due to the above mentioned reason taking inspiration form the field of
unsupervised learning [37], we use a writer-independent dataset to train the
convolution network enabling it to learn diverse set of features. Our CNN
network is trained on EMNIST dataset [38] consisting of a combination of
handwritten English alphabets and digits of which, we only use handwritten
English alphabets. Our network consists of six convolution block, with each
convolution block succeed by Rectified Linear Unit (ReLU) and batch
normalization layer respectively. The block diagram of our Convolution network
is shown in fig. 3. Each convolution layer has been assigned a number from 1
to 6, which is followed by the number of filter and the size of filter
222conv1,$32(3\times 3)/1$ signifies convolution 1 layer consists of 32
filters each of kernel size $(3\times 3)$ with stride of 1 . In our
implementation, we have replaced the max-pooling operation with stride
convolution, as it helps in better visualization of lower layers features of
the network without compromising on accuracy [39].

Figure 3: CNN network used for training English character on EMNIST dataset
[38].

##  5 HOG feature representation

Taking into consideration the size of the feature map obtained by passing the
variable sized image fragment through the convolution block, there is
requirement to transform the output into a fixed sized representation. To
transform the feature map into a fixed-size representation we use Histogram of
Oriented Gradients (HOG) [40] based feature representation. In, this section
we provide the details of our modified HOG representation.

Histogram of Oriented Gradients (HOG) is widely used in the field of object
detection to extract features from an image. This algorithm takes into account
the gradient magnitude and orientation information of an image to encode its
features. This algorithm preserves the spatial information besides being
invariant to small geometric transformations. Our HOG based feature
representation is obtained by implementing the following steps in sequence,
this implementation draws motivation from SIFT feature representation:

  * 1.

An input image is first divided into a fixed number of sub-block, with each
sub-block containing a certain number of pixels, which is adjusted based on
the size of the feature map.

$\begin{split}r_{cell}&=\Bigl{\lceil}\frac{M}{m}\Bigl{\rceil}\\\ \\\
c_{cell}&=\Bigl{\lceil}\frac{N}{n}\Bigl{\rceil}\end{split}$ (2)

Here, $m$ and $n$ represents the number of image grids along the row and
column based on which the size of row and column cell $(r_{cell},c_{cell})$ is
adjusted.

  * 2.

Resulting $(m\times n)$ sub-image blocks are grouped into $b$ number of block,
with each block containing $t$ number of sub-image each of size
($r_{cell}\times c_{cell}$).

  * 3.

Gradient $G_{x}$ and $G_{y}$ along $x$ and $y$ direction calculated for the
whole image, which is used to obtain magnitude and orientation of each pixel
using equation (3).

$\begin{split}\textbf{Magnitude}&=\sqrt{G_{x}^{2}+G_{y}^{2}}\\\ \\\
\textbf{Orientation}&=atan\Big{(}\frac{G_{y}}{G_{x}}\Big{)}\end{split}$ (3)

  * 4.

Magnitude and orientation information obtained in the above step is used to
construct a histogram relative to each sub-block of image. The horizontal axis
of the histogram represents the orientation information discretized into a
fixed set of bins in multiples of
$\phi=\Bigl{\lceil}\frac{360}{k}\Bigl{\rceil}$ degrees, where $k$ refers to
number of bins in the Histogram. Location ($l$) of bin to be voted is selected
based on orientation $(l=\Bigl{\lceil}\frac{Orientation}{\phi}\Bigl{\rceil})$,
and the vote (the value that goes into the bin) is selected based on the
magnitude.

  * 5.

Corresponding to each of the $x^{th}$ sub-images $(1\leq x\leq t)$ in the
$y^{th}$ block $(1\leq y\leq b)$ histogram $S_{xy}$ is constructed as
explained above. Each of these histograms corresponding to a given block $y$
$(1\leq y\leq b)$ is concatenated to get an overall $k\times t$ dimensional
histogram representation for a given block. Finally the histogram for each of
these $t$ blocks are stacked together to generate a final $k\times t\times b$
dimensional feature vector.

$\begin{split}F_{y}&=[S_{1y}\;S_{2y}\;....\;S_{xy}]\quad 1\leq x\leq t\\\ \\\
\textbf{FV}&=\frac{[F_{1}\;F_{2}\;...\;F_{y}]}{||[F_{1}\;F_{2}\;...\;F_{y}]||_{2}}\quad
1\leq y\leq b\end{split}$ (4)

##  6 Determination of Saliency value for convolution filters

The HOG feature representation learned for the output SIFT keypoint fragments
of a Convolution network needs to be stored for training the writer classifier
in subsequent stages. Storing HoG features corresponding to all the filters of
a convolution layer is a memory intensive and computationally expensive task.
A solution to this problem involves combining the output feature map of the
convolution layer to summarize the extracted information of a convolution
block. The simplest way of achieving this objective is by assigning equal
weights to the output feature map of a convolution layer.However, considering
the fact that all the filters of a convolution layer are not equally
informative, we propose a entropy-based method, which assign a saliency value
to each filters of a convolution layer based on the amount of information they
contain. In this section, we explain in detail our proposed entropy-based
method for assigning saliency score to a convolution layer filters.

For calculating saliency score, we select a set of W writes form the database
listed in Table1. Corresponding to each of these selected writers fragments,
HOG feature is extracted relative to each feature map output of a convolution
layer for which saliency value need to be determined. On these HOG features
following operations are performed:

  1. 1.

Extraction of principal components from HOG feature and constructing a
histogram using it.

  2. 2.

Computation of entropy by utilizing the histogram generated in the above step
and using it to assign a saliency value to each convolution layer filter.

In the following subsection we explain in details each of the above mentioned
steps.

###  6.1 Histogram generation using Sparse Principal component analysis

The first step in our objective of assigning a saliency value to a filter,
involves projecting $W$ writer HoG features onto a common subspace (as done in
traditional $K$-means clustering algorithm). This projection matrix represents
the significance of each projected component in the subspace.

For effectively analyzing a data Principle Component Analysis (PCA) is one of
the most commonly used technique. It involves transforming the original
variables into a set of new variables called principle component (PC). These
set of principle component are uncorrelated and represent degree of variation
along the data. Thus, PCA makes model interpretation and visualization easier
by localizing information in only few components, however these components are
constructed using all input variable making them difficult to interpret.

Sparse PCA [41] can be formulated in a variety of ways, and unlike PCA these
method do not yield similar set of solutions. The formulation used by us
involves treating Sparse PCA as a regression problem involving PCA, and using
elastic net penalty to impose sparsity. In, this method PCA is computed by
performing SVD on data matrix X as:

$X=UDV^{T}$ (5)

Here, $Z_{l}=U_{l}D_{ll}$ represents the principal components (PC) of each
observation, and $V_{l}$ represents the loadings of principle component.
$Z_{l}$ can subsequently be obtained by projecting input data $X$ on vector
$V_{l}$ (i.e $XV_{l}=Z_{l}$) using equation(5). Based on this observation PCA
can be treated as a regression problem, in which $Z_{l}$ represents the
response vector and $V_{l}$ represents the regression coefficient.

$\hat{\beta}=\underset{\beta}{\textit{arg\>min}}||Z_{l}-\textbf{X}\beta||^{2}+\lambda||\beta||^{2}+\lambda_{1}||\beta||_{1}$
(6)

Here, $\hat{\textit{V}_{l}}=\frac{\hat{\beta}}{||\hat{\beta}||}$ is an sparse
approximation of $V_{l}$ the original loading vector. These loading vector are
combined to form a combined sparse representation of vector $V$ having L
component.

$\hat{V}=[\hat{V}_{1}\;\hat{V}_{2}\;...\;\hat{V}_{l}\;...\;\hat{V}_{L}]$ (7)

Using the concept of Sparse PCA, the input HOG feature vector $X$ is projected
on the approximated Sparse components as follows:

$\alpha=X\hat{V}$ (8)
$\alpha=\begin{pmatrix}\alpha_{1,1}^{1}&\alpha_{1,2}^{1}&\cdots&\alpha_{1,L}^{1}\\\
\alpha_{2,1}^{1}&\alpha_{2,2}^{1}&\cdots&\alpha_{2,L}^{1}\\\
\vdots&\vdots&\vdots&\vdots\\\
\alpha_{N,1}^{1}&\alpha_{N,2}^{1}&\cdots&\alpha_{N,L}^{1}\\\
\alpha_{1,1}^{2}&\alpha_{1,2}^{2}&\cdots&\alpha_{1,L}^{2}\\\
\alpha_{2,2}^{2}&\alpha_{2,2}^{2}&\cdots&\alpha_{2,L}^{2}\\\
\vdots&\vdots&\vdots&\vdots\\\
\alpha_{N,1}^{2}&\alpha_{N,2}^{2}&\cdots&\alpha_{N,L}^{2}\\\
\alpha_{1,1}^{W}&\alpha_{1,2}^{W}&\cdots&\alpha_{1,L}^{W}\\\
\alpha_{2,2}^{W}&\alpha_{2,2}^{W}&\cdots&\alpha_{2,L}^{W}\\\
\vdots&\vdots&\vdots&\vdots\\\
\alpha_{N,1}^{W}&\alpha_{N,2}^{W}&\cdots&\alpha_{N,L}^{W}\end{pmatrix}$ (9)

Here, $\alpha_{j,k}^{i}$ represents the value of coefficient corresponding to
the $j^{th}$ Sparse component relative to the $k^{th}$ fragment of $i^{th}$
writer. Here, $N$ represents the total number of fragments contributed by each
writer for constructing sparse representation.

Coefficients generated by $W$ writers each contributing $N$ number of
fragments (M = W × N) is used to construct a histogram for each of the
individual components of the sparse vector using equation (10).

$H^{i}_{jb}=\begin{cases}H^{i}_{jb}+1,&\text{if
}h_{b}\leq\alpha_{j,k}^{i}<h_{b+1}\\\ H^{i}_{jb},&\text{otherwise}\end{cases}$
(10)

Here, $b$ represents the value of quantize histogram bins, and $H^{i}_{jb}$
signifies the number of nonzero entries for the $j$ sparse component of a
writer $i$. Following the histogram generation each of histogram is normalized
in the range between 0 and 1 as follows:

$p^{i}_{jb}=\frac{H^{i}_{jb}}{\sum^{B}_{b=1}H^{i}_{jb}}$ (11)

###  6.2 Computation of filter saliency based on Entropy

The normalized histogram $p^{i}_{jb}$ is used to compute entropy of the
principle components for each enrolled writer as:

$E^{i}_{j}=\sum_{b=1}^{B}-p^{i}_{jb}\>\mathrm{log_{2}}\>(p^{i}_{jb})\quad
1\leq j\leq L$ (12)

Here, $E^{i}_{j}$ is the entropy value of the $j^{th}$ principle component
corresponding to $N$ samples of $i^{th}$ enrolled writer in $W$. This entropy
can be represented with the help of following entropy matrix:

$E=\begin{pmatrix}E^{1}_{1}&E^{1}_{2}&\cdots&E^{1}_{L}\\\
E^{2}_{1}&E^{2}_{2}&\cdots&E^{2}_{L}\\\ \vdots&\vdots&\ddots&\vdots\\\
E^{W}_{1}&E^{W}_{2}&\cdots&E^{W}_{L}\end{pmatrix}$ (13)

In this matrix the entries along the row specifies the entropy value relative
to each sparse principle component of the enrolled writer $W$, and the entries
along the column specifies the entropy for a particular sparse component
relative to each of the enrolled writer. These entropy values gives us the
information about the probability distribution of the principal components
corresponding to each writers. These individual entropy values are summed up
across all writers to give an overall entropy value for a particular
convolution filter as follows:

$\phi_{f}=\frac{\sum_{w=1}^{W}\sum_{l=1}^{L}E_{j}^{i}}{W*L}$ (14)

Here, $\phi_{f}$ is the overall value of entropy for the $f^{th}$ filter of a
convolution layer. This overall entropy value signifies the amount of
information contained in a particular filter of a convolution layer. A low
entropy value signifies the presence of information content across some of the
principal components of the filter, thus making other components insignificant
leading to a low entropy value. Such a filter should be assigned a low
saliency value. On the contrary, a higher entropy value signifies, that the
informative content is evenly distributed across a larger number of principle
components thus corresponding filter needs to be assigned a higher saliency
value. Based on these observations we assign saliency value to each of the
filters using their entropy value as:

$w_{f}=\frac{\phi_{f}}{\sum_{f}\phi_{f}}$ (15)

As, a visual interpretation of the above explanation, we generate a histogram
in Fig.4 corresponding to some of the filters of conv1 and conv2 layers in our
convolution network. These histograms correspond to the filters having maximum
and minimum saliency values. For constructing the histogram we have used 10
word samples from each of 50 writers of the IAM database[42]. These value are
arrived at by adding the entries along the rows in equation 13.

Figure 4: (a) and (b) are histogram corresponding to two filters of conv1
having highest and second highest saliency values, (c) and (d) are histogram
corresponding to two filters of conv1 having minimum and second minimum
saliency values. Similarly (e) and (f) are histogram corresponding to two
filters of conv2 having highest and second highest saliency values, (g) and
(h) are histogram corresponding to filters of conv2 having minimum and second
minimum saliency values.

##  7 writer feature generation and classification

Given a handwritten document of a writer containing $N_{w}$ number of word
samples, generating $w_{T}$ number of SIFT keypoints, which upon passing
through a convolution network generates a set of feature map relative to the
number of filters included in that layer as discussed in the earlier sections.
These, feature map output are then the processed further to obtained an
overall HoG representation for each fragment of a writer sample.

For obtaining an overall HOG feature representation form these feature map, we
combine them using different types of pooling strategy. These are discussed
below:

  * 1.

Average pooling: In this pooling methodology equal weightage is assigned to
all the feature map of a convolution layer. These are then combined together
to obtain an overall feature map.

$S^{j}_{p}=\sum_{f=1}^{F}(\frac{1}{F}\times z_{fp}^{j})$ (16)

Here, $z_{fp}^{j}$ represents the feature map corresponding to the $f^{th}$
filter of the convolution layer, for $j^{th}$ writer fragment, and $S^{j}_{p}$
represents the combined feature map. $p$ signifies the writer fragment.

  * 2.

Pre-saliency pooling: In this pooling strategy, a saliency value is assigned
to the feature map of a convolution layer based on their entropy value as
discussed in section 6.

$\tilde{S}^{j}_{p}=\sum_{f=1}^{F}(w_{f}\times z_{fp}^{j})$ (17)

Here, $w_{f}$ is the entropy-based saliency value assigned to each filter $f$
of a convolution layer, and $\tilde{S}^{j}_{p}$ represents the combined
feature map output for the $p^{th}$ fragment of a writer.

After, obtaining the combined feature map using the above mentioned pooling
strategies, these are then transformed into one dimensional feature vector
using modified HoG representation as discussed in section 5.

In addition to the above two pooling strategy. In our work, we also employed a
third typed of pooling Strategy. In this pooling technique, instead of
combining the feature map for generating HOG feature representation as done in
above two pooling strategies, HoG feature is extracted individually for each
feature map of a convolution layer, which are subsequently combined using
corresponding saliency values of each filter in a convolution layer. Thus, in
this technique pooling operation is performed at the later stages. This post-
pooling based saliency technique is mathematically represented as:

$\hat{S}^{j}_{p}=\frac{\sum_{f=1}^{F}(w_{f}\times
FV_{fp}^{j})}{||\sum_{f=1}^{F}(w_{f}\times FV_{fp}^{j})||_{2}}$ (18)

Here, $FV_{fp}^{j}$ represents extracted HoG feature corresponding to the
$f^{th}$ feature map output of the $j^{th}$ writer fragment, and $w_{f}$
represents the saliency value assigned to the $f^{th}$ filter output of the
convolution layer. The effect on classification accuracy by incorporating
these pooling strategy is discussed in section 9.

Following the extraction of HOG feature vector, a one vs all SVM using radial
basis function (RBF) [43] is used to train writing samples. The optimal values
of RBF parameters $C$ and $\gamma$ are obtained by grid search.

During the testing phase, HOG feature vector generated from the SIFT keypoint
fragments of a writer sample is passed is passed through a set of SVM
classifiers to obtain a set of classification score for each of the word
fragments. An, SVM classifier assigns a positive or negative value to input
samples based on its proximity to the hyperplane separating postitve and
negative training samples. These, SVM values are bounded in the range between
$[0-1]$ by passing the SVM classifier value through a sigmoidal function.
Given, a word image containing $\hat{N}$ fragments, the normalised SVM score
generated for each of these fragments is average pooled across each enrolled
writer trained SVM classifier to obtain an overall response for the segmented
word fragments.

$P(s)=\frac{1}{\hat{N}}\sum p_{n}$ (19)

Here, ($\hat{N}$) represents the total number of SIFT fragments generated form
an input word image, $p_{n}$ is the normalized SVM score of the $n^{th}$
fragment for a writer. The final prediction for a word sample ($s$) is made
based on the label ($l$) for which the classifier reports the highest
confidence score as:

$\hat{y}=\underset{l\in\\{1,...,W\\}}{argmax}P_{l}(s)$ (20)

##  8 Dataset description

The proposed method is evaluated on two datsets: IAM [42]and CVL [44].

IAM [42] dataset is the most widely used English language dataset for the
purpose of writer identification. It contains 1593 images of English
handwriting documents collected from a set of 657 writers. Each writer has
contributed a variable number of handwritten document. Out of 657 writers, 301
have contributed two or more handwritten documents, while the rest have
contributed only a single handwritten document. We modified the IAM dataset as
described in [15] by randomly selecting two documents for writers who have
contributed two or more document samples in the database. On the other hand
for a writer contributing only one document, it is divided into half one half
of which is used for training and the other half for testing. As the bounding
boxes for the word image have been provided in the dataset, we collect the
word image from the generated training and testing set for our
experimentation.

CVL [44] dataset contains handwritten text documents from 310 writers of which
27 writers have contributed 7 text documents, while the rest have contributed
5 text documents. Each writer contributed one text document in German and the
rest in English language. In our experimentation, we used only the text
document written in English. We follow the same methodology as is done in [29]
for dividing the dataset into training and testing sets. Similar to the IAM
dataset segmented words are made available in this dataset.

Table 1 gives a detailed overview of all the datasets used in our experiments.

Table 1: Overview of the datasets used in experiments Dataset | Number of writers | Language
---|---|---
IAM | 657 | English
CVL | 310 | English

##  9 Experiment and Discussion

In this section we carry out a set of experiments of our proposed algorithm on
two benchmark datasets. These set of experiments helps us in choosing a proper
set of parameters to be used for increasing the efficacy of our proposed
writer identification system.

###  9.1 Implementation details

The proposed Convolution network is built on the TensorFlow framework. Adam
optimizer is used for optimizing the network, with a weight decay factor of
$0.1$ every ten epoch. The model is trained for 50 epochs. Word fragments are
normalized (between$[0-1]$) before feeding to the convolution network for
feature extraction.

In order to extract the HOG feature vector from SIFT keypoint as discussed in
section 5, we select the value of $(m,n)$ to be $(4,4)$ which divides the cov1
and conv2 feature map into 16 sub-blocks. These 16 sub-blocks are grouped into
$t=4$ quadrants, with each quadrant containing a combination of $b=4$ sub-
blocks. Since, the size of the feature map in a convolution network decreases
with increasing depth of the network, in order to maintain the spacial
consistency of the feature map value of $m$ and $n$ is adjusted accordingly.
For extracting the HOG features from conv3 feature map the value of $(m,n)$ is
set to $(2,2)$, as the size of the conv3 layer is half the size of the conv2
layer. Similarly, the value of $t$ and $b$ is also adjusted accordingly.

###  9.2 Performance with varying Bins B and convolution layers

In this subsection, we evaluate the effect of bin size ($B$) on the overall
performance of our writer identification system on approximately one third
dataset (100 for CVL and 200 for IAM). We vary the value of bin size ($B$)
from 6 to 12 in steps of two. Table 2 tabulates the result of our strategy for
different databases. We observe that the best average identification rate for
the IAM database corresponding to conv1 and conv2 layers are 91.15 and 90.25
respectively which is achieved for bin size 10. Similarly, for the CVL
database, we achieve the best average accuracy of 82.97 and 80.95
corresponding to bin size 10. As, we move into con3 layer feature map, the
identification rate decreases with respect to conv1 and conv2 layers.

Based on the above tabulated results, it can be inferred that initial layers
of the convolution neural network (namely conv1 and conv2) capture most of the
information that is helpful in differentiating one set of writers from
another. As we move deeper into the convolution network the resolution of the
image decreases, thus, the underlying information becomes more abstract and
less visual interpretative resulting in loss of discriminability among
writers(as shown using conv3 result). In the subsequent set of experiments, we
will mainly lay emphasis on conv1 and conv2 layers corresponding to the
optimal bin size (as reported in Table 2).

Table 2: Comparison of average identification rates (in % for one third data
set samples) at word level for proposed algorithm with different bin size. The
best identification rate is marked in bold

Convolution layer | Bin size | IAM | CVL
---|---|---|---
Top1 | Top5 | Top1 | Top5
Conv1 | 6 | 89.8 | 95.45 | 81 | 92.45
8 | 90.15 | 95.85 | 82 | 93.68
10 | 91.15 | 97.15 | 82.97 | 94.59
12 | 89.85 | 95.65 | 81.21 | 93.25
Conv2 | 6 | 89.4 | 95.5 | 79 | 92.35
8 | 89.8 | 95.3 | 79.95 | 93.25
10 | 90.25 | 96.75 | 80.95 | 93.58
12 | 88.55 | 95.15 | 80.80 | 93.38
Conv3 | 6 | 70 | 88.15 | 47 | 77.85
8 | 73.35 | 89.81 | 57.8 | 83.25
10 | 79.97 | 91.77 | 64.45 | 87.9
12 | 81.88 | 92.07 | 67.15 | 88.55

###  9.3 Influence of weighting strategy

In this experiment, we have consider the effect of incorporating different
weighting strategy on the overall accuracy of the proposed writer
identification system. These weighting strategies involve: mean-pooling (16),
pre-pooling (17) and post-pooling (18). A detailed discussion on these pooling
strategies is provided in section 7.

For analyzing the effect of accuracy using various pooling methodology, we
randomly select a set of 10 word samples per enrolled writer in the database.
The result obtained by analysing various pooling strategy is tabulated is
table3. Based on table 3 we observe, that the performance of mean pooling
methodology is lowest when compared to other two pooling strategy. This, is
due to the fact that mean pooling assigns equal importance to all the filters
of a convolution layers, due to which additional information contained in some
of the convolution filter is not utilized properly. On, the other hand other
two pooling strategy (pre and post) uses saliency based method that estimates
in advance the relative importance of each convolution filter output. Thus,
providing extra information related to the filter output, which is helpful in
increasing the overall accuracy of the system. Experimental result also reveal
that among the two pooling strategy (pre and post), post-pooling performs
better than pre-pooling. This, can be attributed to the fact that various
filter output of a convolution layer are complementary to each other, as such
using saliency values beforehand sometimes leads to masking of some important
features in the combined feature map resulting in a loss of some information.
On, the other hand in post-pooling strategy weights are assigned to the
extracted HOG feature in a convolution layer separately, as such some hidden
information can be captured effectively leading to increase in model accuracy.

Table 3: Effect of accuracy achieved (in %) on IAM and CVL dataset using
various weighting strategies

| Conv1 | Conv2
---|---|---
Database | Average weighting | pre weighting | post weighting | Average weighting | pre weighting | post weighting
IAM | 84.77 | 85.02 | 86.07 | 84.42 | 84.62 | 85.81
CVL | 77.53 | 78.05 | 78.24 | 75.29 | 75.54 | 77.79

###  9.4 Score Fusion

Let $I$ be an input word image generating $w_{T}$ number of HoG features
corresponding to conv1 and conv2 layers respectively. These HOG feature when
passed through a trained SVM classifier trained on conv1 and conv2 layer HOG
features generates $P_{1}^{I}(s)$ and $P_{2}^{I}(s)$ score respectively. These
scores are then fused together to generate a final classification score
$D^{I}$ as:

$D^{I}(s)=\alpha P_{1}^{I}(s)+(1-\alpha)P_{2}^{I}(s)$ (21)

Where, $0\leq\alpha\leq 1$ is the weight. The component $\alpha$ assigns a
weight to the individual conv1 and conv2 classifiers by taking into account
the effectiveness of the individual classifier in classifying a writer. The
parameter $\alpha$ is database dependent and is determined based on validation
data of one third enrolled writer in the database.

Once, the parameter $\alpha$ is selected the final prediction score for each
writer is calculated individually, following which the prediction for
candidate writer $j^{*}$ is made by the system as follows:

$j^{*}=\underset{j}{arg\>max}\;D^{I}(s,j)$ (22)

###  9.5 Performance of Writer Identification with varying number of words
Images

In order to show the robustness of our proposed system with respect to the
amount of handwritten word available, we calculate the TOP-1 performance of
our system with respect to different number of handwritten words across two
databases. In this experiment we randomly select $N$ number of word images for
each enrolled writer. SIFT fragment extracted from these word samples is
passed through HOG classifier corresponding to conv1 and conv2 layers
following which these scores are combined to obtain overall accuracy score.
This procedure is repeated 10 times and the average result for different $N$
values is shown with the help of fig.5.

From fig.5, it can be inferred that the performance of proposed writer
identification system increases significantly as the number of available word
sample of a writer increases form one to two, and it stabilizes as the number
of available word sample reaches four or more words. This result shows the
efficacy of our proposed algorithm in recognising writer in situation where
limited amount of writer data is available for testing.

Figure 5: Performance (Top1) of writer identification using different numbers
of words on the IAM and CVL data set.

###  9.6 Performance comparison of proposed system with different features on
word Image

In this section we evaluate the performance of our proposed system with
traditional handcrafted features based system on word image. Table 4
summarizes the result of different writer identification system considering
word image as input. From the table, it can be observe that the performance of
traditional handcrafted features based system on input word image is low. This
is due to the fact that these algorithm make writer prediction based on
statistical information collected from the input image. In order to generate
stable representation based on statistical information, these algorithms
require certain minimum amount of text samples. In the case of word image the
statistical information captured is insufficient to generate a stable
representation of the input text sample. On the contrary due to the presence
of multiple filter in each convolution layer of a convolution network, it can
capture a diverse quantity of information from the training data, thus
increasing the overall performance of the system. In addition to this, it can
also be deduced form table 4,that a convolution network train on writer-
independent auxiliary dataset is able to capture general writer
characteristics more effectively compared to a network trained on a writer
dependent dataset.

Table 4: Comparison of Writer Identification performance (in % ) on full
database for word image samples

Method | IAM | CVL
---|---|---
Top1 | Top5 | Top1 | Top5
Hinge[4] | 13.8 | 28.3 | 13.6 | 29.7
Quill[45] | 23.8 | 44.0 | 23.8 | 46.7
CoHinge[46] | 19.4 | 34.1 | 18.2 | 34.2
QuadHinge[46] | 20.9 | 37.4 | 17.8 | 35.5
COLD[47] | 12.3 | 28.3 | 12.4 | 29.0
Chain Code Pairs[19] | 12.4 | 27.1 | 13.5 | 30.3
Chain Code Triplets[19] | 16.9 | 33.0 | 17.2 | 35.4
WordImgNet[29] | 52.4 | 70.9 | 62.5 | 82.0
FragNet-64[29] | 72.2 | 88.0 | 79.2 | 93.3
Veritcal GR-RNN(FGRR)[30] | 83.3 | 94.0 | 83.5 | 94.6
Horizontal GR-RNN(FGRR)[30] | 82.4 | 93.8 | 82.9 | 94.6
Proposed Methodology with average pooling (conv1+conv2) | 85.87 | 92.30 | 79.70 | 91.94
Proposed Methodology with pre weighting (conv1+conv2) | 86.16 | 92.77 | 80.16 | 92.14
Proposed Methodology with post weighting (conv1+conv2) | 86.68 | 92.96 | 80.57 | 92.35

###  9.7 Performance comparison of proposed system with other methods on page
Image

In this section we evaluate the performance of our proposed algorithm on page
images. For evaluating the writer performance on page images, we calculate the
individual SVM classification score of each word image contained in the page
of writer sample, following which these scores are aggregated to arrive at an
overall classification score. This process is represented mathematical using
below equation.

$P_{page}=\frac{1}{N_{w}}\sum_{t\in page}^{N_{w}}P(t)$ (23)

where $P_{page}$ is the overall writer classification score generated based on
words samples present in a $page$ image. $P(t)$ is the individual
classification score of each word $t$ contained in a $page$ and $N_{w}$ is the
total number of word in the $page$ image. Table 5 and 6 shows the overall
performance of our algorithm on page level data when compared with other state
of art algorithms for IAM and CVL datasets.

Based on table 5 and 6 it can be observed that the performance of the proposed
writer identification algorithm on page image is better than word image due to
the availability of large number of word samples contained in a page. Our word
based writer identification algorithm achieves a higher identification
accuracy when compared with other word based writer identification algorithm
(such as WordImagenet, Fragnet[29], GR-RNN [30], and [48]) for page level data
on IAM datset. For CVL[44] dataset our proposed algorithm achieves top1
accuracy of 99.0%, which is comparable to other state of art algorithm for
page level data. The low classification accuracy of our proposed system on
page level data for CVL dataset as compared to other algorithm is due to the
fact that the written content in case of CVL datase is same for every writer
due to which, the model in some of the case is unable to differentiate between
writers having a similar style (as our proposed model is not trained to
capture writer specific features), thus leading to false writer identification
in some of the cases, as depicted with the help of figure 6. This result
further affirms the inference made in the previous discussion regarding the
robustness of writer independent model in learning general writer
characteristics.

Table 5:  Comparison of State of art methods on IAM database

Reference | Number of Writers | Top 1 accuracy
---|---|---
Siddiqui and Vincent[19] | 650 | 91.0
He and Schomaker[46] | 650 | 93.2
Khalifa et.al.[49] | 650 | 92.0
Hadjadji and Chibani[50] | 657 | 94.5
Wu et.al.[15] | 657 | 98.5
Khan et.al.[16] | 650 | 97.8
Nguyen et.al.[48] | 650 | 93.1
WordImagenet | 657 | 95.8
FragNet-64[29] | 657 | 96.3
GR-RNN[30] | 657 | 96.4
Proposed Methodology with Post weighting | 657 | 98.17

Table 6: Comparison of state of art method on CVL database

Reference | Number of Writers | Top 1 accuracy
---|---|---
Fiel and sablating[22] | 309 | 97.8
Tang and Wu[36] | 310 | 99.7
Christlein et.al[35] | 310 | 99.2
Khan et.al.[16] | 310 | 99.0
WordImagenet | 310 | 98.8
FragNet-64[29] | 310 | 99.1
GR-RNN[30] | 310 | 99.3
Proposed Methodology with Post weighting | 309 | 99.0

Figure 6: Example of false acceptance. Samples included in (a) and (b) are
from different writers, but is identified as same writer by the proposed
algorithm.

##  10 Conclusion

In this work we have proposed an offline test-independent writer
identification system based on word image. Our algorithm uses SIFT keypoint to
detect various type of features from a word image, these feature vary form
word to allograph. Such type of diverse features helps in making our system
more robust as compared to a system trained using word image as whole. The
major contribution of our proposed work can be listed as follows: (i) Use of a
convolution network trained on a auxiliary dataset instead of an end to end
trained network on writer dependent data. Thus, making the algorithm better
suited to extract writer features without the need of retraining the network.
(ii) Use of modified HOG feature representation to capture spatial relation
between convolution later output of various SIFT keypoint corresponding to
different writers. (iii) proposing an entropy based weighting strategy to
assign importance to each filter of a convolution layer.

One of the limitation of our proposed algorithm is that it requires a good
quality of segmented word image, which is a very challenging task to achieve
on a highly cursive written document. In our future works we would like to
address this shortcoming and work on an algorithm which could perform writer
identification on any handwritten document.

## References

  * Xu et al. [2016] Y. Xu, L. Fei, W. Jie,  Discriminative and robust competitive code for palmprint recognition,  IEEE Transactions on Systems, Man, and Cybernetics: Systems PP (2016) 1–10.
  * Chi et al. [2018] W. Chi, J. Wang, M. Q.-H. Meng,  A gait recognition method for human following in service robots,  IEEE Transactions on Systems, Man, and Cybernetics: Systems 48 (2018) 1429–1440.
  * Fernandez-de Sevilla et al. [2010] R. Fernandez-de Sevilla, F. Alonso-Fernandez, J. Fierrez, J. Ortega-Garcia,  Forensic writer identification using allographic features,  in: 2010 12th International Conference on Frontiers in Handwriting Recognition, 2010, pp. 308–313.
  * Bulacu et al. [2007] M. Bulacu, R. van Koert, L. Schomaker, T. van der Zant,  Layout analysis of handwritten historical documents for searching the archive of the cabinet of the dutch queen,  in: Ninth International Conference on Document Analysis and Recognition (ICDAR 2007), volume 1, 2007, pp. 357–361.
  * He et al. [2014] S. He, P. Sammara, J. Burgers, L. Schomaker,  Towards style-based dating of historical documents,  in: 2014 14th International Conference on Frontiers in Handwriting Recognition, 2014, pp. 265–270.
  * Faundez-Zanuy et al. [2020] M. Faundez-Zanuy, J. Fierrez, M. Ferrer, M. Diaz, R. Tolosana, R. Plamondon,  Handwriting biometrics: Applications and future trends in e-security and e-health,  Cognitive Computation 12 (2020).
  * Sharma and Sundaram [2017] A. Sharma, S. Sundaram,  A novel online signature verification system based on gmm features in a dtw framework,  IEEE Transactions on Information Forensics and Security 12 (2017) 705–718.
  * Xiong et al. [2017] Y.-J. Xiong, Y. Lu, P. S. P. Wang,  Off-line text-independent writer recognition: A survey,  International Journal of Pattern Recognition and Artificial Intelligence 31 (2017) 1756008\.
  * Said et al. [2000] H. Said, T. Tan, K. Baker,  Personal identification based on handwriting,  Pattern Recognition 33 (2000) 149–160.
  * Bertolini et al. [2013] D. Bertolini, L. Soares de Oliveira, E. Justino, R. Sabourin,  Texture-based descriptors for writer identification and verification,  Expert Systems with Applications 40 (2013) 2069–2080.
  * Heikkila and Ojansivu [2009] J. Heikkila, V. Ojansivu,  Methods for local phase quantization in blur-insensitive image analysis,  in: 2009 International Workshop on Local and Non-Local Approximation in Image Processing, LNLA 2009, 2009, pp. 104 – 111.
  * Djeddi et al. [2013] C. Djeddi, I. Siddiqi, L. Souici-Meslati, A. Ennaji,  Text-independent writer recognition using multi-script handwritten texts,  Pattern Recognition Letters 34 (2013).
  * Bulacu et al. [2003] M. Bulacu, L. Schomaker, L. Vuurpijl,  Writer identification using edge-based directional features,  in: Seventh International Conference on Document Analysis and Recognition, 2003. Proceedings., 2003, pp. 937–941.
  * Hannad et al. [2016] Y. Hannad, I. Siddiqi, Y. Elkettani,  Writer identification using texture descriptors of handwritten fragments,  Expert Systems with Applications 47 (2016) 14–22.
  * Wu et al. [2014] X. Wu, Y. Tang, W. Bu,  Offline text-independent writer identification based on scale invariant feature transform,  IEEE Transactions on Information Forensics and Security 9 (2014) 526–536.
  * Khan et al. [2018] F. Khan, F. Khelifi, M. Tahir, A. Bouridane,  Dissimilarity gaussian mixture models for efficient offline handwritten text-independent identification using sift and rootsift descriptors,  IEEE Transactions on Information Forensics and Security PP (2018) 1–1.
  * Newell and Griffin [2014] A. J. Newell, L. D. Griffin,  Writer identification using oriented basic image features and the delta encoding,  Pattern Recogn. 47 (2014) 2255–2265. URL: https://doi.org/10.1016/j.patcog.2013.11.029. doi:10.1016/j.patcog.2013.11.029.
  * Schomaker and Bulacu [2004] L. Schomaker, M. Bulacu,  Automatic writer identification using connected-component contours and edge-based features of uppercase western script,  IEEE Transactions on Pattern Analysis and Machine Intelligence 26 (2004) 787–798.
  * Siddiqi and Vincent [2010] I. Siddiqi, N. Vincent,  Text independent writer recognition using redundant writing patterns with contour-based orientation and curvature features,  Pattern Recognition 43 (2010) 3853–3865.
  * Schomaker et al. [2015] L. Schomaker, M. Wiering, H. Sheng,  Junction detection in handwritten documents and its application to writer identification,  Pattern Recognition 48 (2015).
  * Akram et al. [2019] B. Akram, C. Djeddi, A. Gattal, I. Siddiqi, M. Tahar,  Handwriting based writer recognition using implicit shape codebook,  Forensic Science International 301 (2019).
  * Fiel and Sablatnig [2015] S. Fiel, R. Sablatnig,  Writer identification and retrieval using a convolutional neural network,  in: International Conference on Computer Analysis of Images and Patterns, Springer, 2015, pp. 26–37.
  * Xing and Qiao [2016] L. Xing, Y. Qiao,  Deepwriter: A multi-stream deep cnn for text-independent writer identification,  in: 2016 15th International Conference on Frontiers in Handwriting Recognition (ICFHR), 2016, pp. 584–589.
  * Christlein et al. [2017] V. Christlein, M. Gropp, S. Fiel, A. Maier,  Unsupervised feature learning for writer identification and writer retrieval,  in: 2017 14th IAPR International Conference on Document Analysis and Recognition (ICDAR), volume 1, IEEE, 2017, pp. 991–997.
  * Yang et al. [2016] W. Yang, L. Jin, M. Liu,  Deepwriterid: An end-to-end online text-independent writer identification system,  IEEE Intelligent Systems 31 (2016) 45–53.
  * Rehman et al. [2019] A. Rehman, S. Naz, M. I. Razzak, I. A. Hameed,  Automatic visual features for writer identification: A deep learning approach,  IEEE Access 7 (2019) 17149–17157.
  * Sulaiman et al. [2019] A. Sulaiman, K. Omar, M. F. Nasrudin, A. Arram,  Length independent writer identification based on the fusion of deep and hand-crafted descriptors,  IEEE Access 7 (2019) 91772–91784.
  * He and Schomaker [2019] S. He, L. Schomaker,  Deep adaptive learning for writer identification based on single handwritten word images,  Pattern Recognition 88 (2019) 64–74.
  * He and Schomaker [2020] S. He, L. Schomaker,  Fragnet: Writer identification using deep fragment networks,  IEEE Transactions on Information Forensics and Security 15 (2020) 3013–3022.
  * He and Schomaker [2021] S. He, L. Schomaker,  Gr-rnn: Global-context residual recurrent neural networks for writer identification,  Pattern Recognition 117 (2021) 107975.
  * Felzenszwalb et al. [2010] P. F. Felzenszwalb, R. B. Girshick, D. McAllester, D. Ramanan,  Object detection with discriminatively trained part-based models,  IEEE Transactions on Pattern Analysis and Machine Intelligence 32 (2010) 1627–1645.
  * Lowe [2004] D. G. Lowe,  Distinctive image features from scale-invariant keypoints,  Int. J. Comput. Vision 60 (2004) 91–110. doi:10.1023/B:VISI.0000029664.99615.94.
  * Zhang et al. [2003] B. Zhang, S. N. Srihari, S. Lee,  Individuality of handwritten characters,  in: Seventh International Conference on Document Analysis and Recognition, 2003. Proceedings., volume 3, IEEE Computer Society, 2003, pp. 1086–1086.
  * Tan et al. [2010] G. Tan, C. Viard-Gaudin, A. Kot,  Individuality of alphabet knowledge in online writer identification,  IJDAR 13 (2010) 147–157.
  * Christlein et al. [2017] V. Christlein, D. Bernecker, F. Hnig, A. Maier, E. Angelopoulou,  Writer identification using gmm supervectors and exemplar-svms,  Pattern Recogn. 63 (2017) 258–267.
  * Tang and Wu [2016] Y. Tang, X. Wu,  Text-independent writer identification via cnn features and joint bayesian,  in: 2016 15th International Conference on Frontiers in Handwriting Recognition (ICFHR), 2016, pp. 566–571.
  * Dosovitskiy et al. [2014] A. Dosovitskiy, J. T. Springenberg, M. Riedmiller, T. Brox,  Discriminative unsupervised feature learning with convolutional neural networks,  Advances in neural information processing systems 27 (2014).
  * Cohen et al. [2017] G. Cohen, S. Afshar, J. Tapson, A. van Schaik,  Emnist: Extending mnist to handwritten letters,  in: 2017 International Joint Conference on Neural Networks (IJCNN), 2017, pp. 2921–2926.
  * Springenberg et al. [2014] J. Springenberg, A. Dosovitskiy, T. Brox, M. Riedmiller,  Striving for simplicity: The all convolutional net (2014).
  * Dalal and Triggs [2005] N. Dalal, B. Triggs,  Histograms of oriented gradients for human detection,  in: 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 1, 2005, pp. 886–893 vol. 1.
  * Zou et al. [2004] H. Zou, T. Hastie, R. Tibshirani,  Sparse principal component analysis,  Journal of Computational and Graphical Statistics 15 (2004) 2006.
  * Marti and Bunke [2002] U.-V. Marti, H. Bunke,  The iam-database: An english sentence database for offline handwriting recognition,  International Journal on Document Analysis and Recognition 5 (2002) 39–46.
  * Burges [1998] C. J. C. Burges,  A tutorial on support vector machines for pattern recognition 2 (1998) 121–167.
  * Kleber et al. [2013] F. Kleber, S. Fiel, M. Diem, R. Sablatnig,  Cvl-database: An off-line database for writer retrieval, writer identification and word spotting,  in: 2013 12th International Conference on Document Analysis and Recognition, 2013, pp. 560–564.
  * Brink et al. [2012] A. Brink, J. Smit, M. Bulacu, L. Schomaker,  Writer identification using directional ink-trace width measurements,  Pattern Recognition 45 (2012) 162–171.
  * Sheng and Schomaker [2017] H. Sheng, L. Schomaker,  Beyond ocr: Multi-faceted understanding of handwritten document characteristics,  Pattern Recognition 63 (2017) 321–333. doi:10.1016/j.patcog.2016.09.017.
  * Sheng and Schomaker [2016] H. Sheng, L. Schomaker,  Writer identification using curvature-free features,  Pattern Recognition 63 (2016) 451–464.
  * Nguyen et al. [2018] H. Nguyen, C. Nguyen, T. Ino, B. Indurkhya, M. Nakagawa,  Text-independent writer identification using convolutional neural network,  Pattern Recognition Letters 121 (2018).
  * Khalifa et al. [2015] E. Khalifa, S. A. Al-Maadeed, M. A. Tahir, A. Bouridane, A. Jamshed,  Off-line writer identification using an ensemble of grapheme codebook features,  Pattern Recognit. Lett. 59 (2015) 18–25.
  * Hadjadji and Chibani [2018] B. Hadjadji, Y. Chibani,  Two combination stages of clustered one-class classifiers for writer identification from text fragments,  Pattern Recognition 82 (2018). doi:10.1016/j.patcog.2018.05.001.