SCAN: Sliding Convolutional Attention Network for Scene Text Recognition

06/02/2018 ∙ by Yi-Chao Wu, et al. ∙ 0

Scene text recognition has drawn great attentions in the community of computer vision and artificial intelligence due to its challenges and wide applications. State-of-the-art recurrent neural networks (RNN) based models map an input sequence to a variable length output sequence, but are usually applied in a black box manner and lack of transparency for further improvement, and the maintaining of the entire past hidden states prevents parallel computation in a sequence. In this paper, we investigate the intrinsic characteristics of text recognition, and inspired by human cognition mechanisms in reading texts, we propose a scene text recognition method with sliding convolutional attention network (SCAN). Similar to the eye movement during reading, the process of SCAN can be viewed as an alternation between saccades and visual fixations. Compared to the previous recurrent models, computations over all elements of SCAN can be fully parallelized during training. Experimental results on several challenging benchmarks, including the IIIT5k, SVT and ICDAR 2003/2013 datasets, demonstrate the superiority of SCAN over state-of-the-art methods in terms of both the model interpretability and performance.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 6

page 9

page 10

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Texts in the natural scene images convey rich and high-level semantic information which is important for image understanding. With the development of information technology, scene text recognition (STR) plays much more significant roles for image retrieval, intelligent transportation, robot navigation and so on. Consequently, STR has become a hot research topic in computer vision and artificial intelligence in recent years. Although the field of text recognition for scanned documents has observed tremendous progresses  

[Graves et al.2009] [Wu et al.2017], STR still remains a challenging problem, mainly due to the large variations in the aspects of background, resolution, text font and color, as shown in Fig. 1.

Figure 1: Examples of difficult scene text images.

Many efforts have been devoted to attacking the difficulties of scene text recognition. Comprehensive surveys can be found in  [Ye and Doermann2015] [Zhu et al.2016]. Traditional recognition schemes  [Wang et al.2011] [Bissacco et al.2013] [Yao et al.2014] [Shi et al.2013]

usually adopt the bottom-up character detection or segmentation scheme. This approach has good interpretation since they can locate the position and label of each character. However, its performance is severely confined by the difficulty of character segmentation, and moreover, the method usually requires millions of manually labeled training samples for character classifier training (such as PhotoOCR  

[Bissacco et al.2013]), which is both expensive and time-consuming.

Nowadays, deep neural network based frameworks have dominated the field of STR, by utilizing the top-down scheme which is independent of the segmentation performance and can be jointly optimized with the weakly labeled data. As the length of both input data and recognition result may vary drastically for STR, it is natural to make use of recurrent networks to capture context information and map them to an output sequence with variable length. In order to enhance the recognition performance, it is a common practice to combine CNN and RNN layers into hierarchical structures. RNN based method  [Shi et al.2016] [Cheng et al.2017] [Shi et al.2017] [Lee and Osindero2016] [Wang and Lu2017] is the dominant approach for dealing with the STR problem, and has obtained the state-of-the-art results on several challenging benchmarks. However, it mainly suffers two problems: (1) The training speed can be very slow as RNNs maintain a hidden state of the entire past that prevents parallel computation within a sequence; (2) The training process is tricky due to the gradient vanishing and exploding. Although the CNN based method can overcome the two defects of recurrent models, it is not widely used in the STR problem as CNNs often operate on the problems where the inputs and outputs are with fixed dimensions, and therefore they are incapable of producing a variable-length label sequence. A few methods [Jaderberg et al.2016] [Jaderberg et al.2015] adopt the holistic methods with CNNs, which recognize words or text lines as a whole without character modeling.

Figure 2: Illustration of the acuity of foveal vision in reading. Around the fixation point only limited context information can been seen with 100% acuity while reading the word ”Traffic”.

On the other hand, there has been criticism that current state-of-the-art methods are usually applied in a black box manner and lack of interpretability for further improvement. Although the recurrent attention model can focus on part of the character, it is still unable to locate the boundary of each character. Modern cognitive psychology research points out that reading consists of a series of saccades and fixations  

[Wikipedia2017]. Eyes do not move continuously along a line of text, but make short, rapid movements (saccades) intermingled with short stops (fixations). A diagram demonstrating the acuity of foveal vision in reading is shown in Fig. 2. Inspired by the above observations, and in order to realize this kind of biology phenomena into a computing model, we propose a novel method called SCAN (the abbreviation of Sliding Convolutional Attention Network) for scene text recognition with the purpose of interpretation and high performance.

The major contributions of this work are in three respects. First, we investigate the intrinsic characteristics of text recognition, and propose a novel scene text recognition method to imitate the mechanisms of saccades and fixations. Second, the model we propose for STR is entirely convolutional, which can be fully parallelized during training to better exploit the GPU hardware and optimization is easier since the number of non-linearities is fixed and independent of the input length. Third, we conduct extensive experiments on several benchmarks to demonstrate the superiority of the proposed method over state-of-the-art methods. Because of the good interpretability and flexibility of SCAN, we may easily utilize existing sophisticated network structures and post-processing techniques for further improvement. In addition, to the best of our knowledge, this is the first successful work to make use of convolutional sequence learning in the field of scene text recognition.

The work of  [Yin et al.2017] is close to ours in that sliding convolutional character model is used. However, this method still lacks of transparency, as it is a CTC based method, and its performance is not competitive compared with best systems. Different from the existing approaches, in this study, we combine the merits of both bottom-up and top-down methods, and propose an entirely convolutional model for faster training, better interpretability and higher performance.

The rest of this paper is organized as follows: Section 2 gives a detailed introduction of the proposed method; Section 3 presents experimental results, and Section 4 offers concluding remarks.

2 Proposed Model

The SCAN recognition system is diagrammed in Fig. 3. It consists of three major parts, namely a sliding window layer, a convolutional feature extractor, and a convolutional sequence to sequence learning module including both the convolutional encoder and the convolutional decoder.

Figure 3: The framework of SCAN. It consists of three parts: a sliding window layer, a convolutional feature extractor, and a convolutional sequence to sequence learning network.

The sliding window layer splits the textline into overlapped windows. On the top of sliding window, a convolutional feature extractor is built to extract the discriminative features. Finally, a convolutional sequence to sequence learning module is adopted to transform feature sequence into the result sequence. The whole system can be fully parallelized and jointly optimized independent of the input length, as all these three layers can be processed simultaneously while training.

2.1 Multi-Scale Sliding Window

When humans read a text line, their eyes do not move continuously along a line of text, but make short rapid movements intermingled with short stops. During the time that the eye is stopped, new information is brought into the processing, but during the movements, the vision is suppressed so that no new information is acquired  [Wikipedia2017]. Inspired by this, we use exhaustive scan windows with suitable step to imitate the saccade, the centre of the scan window could be a potential fixation point, while the perceptual span can be referred to the window size. Therefore, this mechanism can be simplified to the sliding window.

(a) Characters with various width
(b) Multi-scale sliding window
Figure 4: Illustration of multi-scale sliding window mechanism. The model can take different glimpses to adjust different character fonts and capture more accurate context information.

If we assume the model only skips one character in each saccade as a unskilled people, we could fix the sliding window to the size where a character can be covered completely. Although after height normalization, characters usually have approximately similar width in the text image, the aspect ratio of the character may still vary between different fonts (Fig. 4(a)). Thus, we propose to use the sliding window with multi scales, as shown in Fig 4(b). The model can then take different glimpses to adjust different character fonts and capture more accurate context information. Those different glimpses will be proportionally resized to the same size, and then concatenated together as multi-channel inputs which will be fed to the convolutional feature extractor.

2.2 Convolutional Feature Extraction

Although we may use any feature extraction method (such as HOG  

[Dalal and Triggs2005]) to embed the resized windows in distributional space, we adopt the CNN based approach for its superior performance in the field of pattern recognition and its ability of easy integrating into other modules for end-to-end training. We build a 14-layer network for convolutional feature extraction 111We may easily adopt existing sophisticated network structures for further improvement., as shown in Fig. 5. The structure is inherited from  [Wu et al.2017]

, while we remove the Softmax layer of the original network. In this way, the resized window can be finally reduced to a 200-dimensional high-level representation.

Figure 5: The architecture for convolutional feature extraction.

2.3 Convolutional Sequence Learning

After convolutional feature extraction, we obtain a deep feature sequence representing the information captured from a series of windows, which can be denoted as

. The process of fixations can be formulated by a convolutional sequence to sequence learning module to generate the recognition result .

The recurrent neural network based encoder-decoder architectures  [Sutskever et al.2014] have dominated the field of sequence to sequence learning. To make full use of the context information, it is better to use architectures with attention  [Bahdanau et al.2015], which compute the conditional input as a weighted sum of encoder state representations at each time step. The weights of the sum are referred to as attention scores and allow the network to focus on different parts of the input sequence as it generates the output sequences, while in this work, we interpret it as the mechanism of fixation. As for the STR problem, all the previous attention based frameworks employ the recurrent models to model long-term dependencies.

Instead of relying on RNNs to compute intermediate encoder states and decoder states , we turn to use a fully convolutional architecture for sequence to sequence modeling shown in Fig. 3. Gehring et al.  [Gehring et al.2017] propose the convolutional sequence to sequence learning architecture for the first time, which is successfully applied to the machine translation problem with better accuracy and faster training speed.

In order to equip our model with a sense of order, the input feature representation is combined with the absolute position embedding of input elements to obtain the input element representations . We proceed similarly for output elements, denoted as .

For convolutional sequence learning, both encoder and decoder networks compute intermediate states based on a fixed number of input elements using a simple layer structure. We denote the output of the -th layer as for the encoder network, and for the decoder network. A one dimensional convolution exists in each layer followed by a non-linearity. For a network with a single layer and kernel width , each resulting state contains information over input elements. Stacking several blocks on top of each other increases the number of input elements represented in a state. The final distribution over the possible next target elements can be calculated by transforming the top decoder output via a linear layer with weights and bias :

(1)

The convolutional sequence learning network adopts a separate attention mechanism for each decoder layer. To compute the attention vector, the current decoder state

is combined with an embedding of the previous target element :

(2)

For decoder layer , the attention of state is a dot-product between the decoder state summary and each output of the last encoder block :

(3)

The input to the current decoder layer, denoted as , is computed as a weighted sum of the encoder outputs as well as the input element embeddings :

(4)

where encoder output represents potentially large input contexts, and input embedding provides point information about a specific input element that is useful when making a prediction. Then we added to the output of the corresponding decoder layer once it has been computed.

For multi-step attention mechanism, the attention of the first layer determines a useful source context which is then fed to the second layer that takes this information into account when computing attention. This makes it easier for the model to take into account which previous inputs have been attended to already. While for recurrent nets, this information is in the recurrent state and needs to survive several non-linearities. The convolutional architecture also allows to batch the attention computation across all elements of a sequence compared to RNNs.

2.4 Model Training

Denote the training dataset by , where is a training image of textline, is a ground truth label sequence. To train the model, we minimize the negative log-likelihood over :

(5)

where is the window sequence produced by sliding on the image

. This objective function calculates a cost value directly from an image and its ground truth label sequence. Therefore, the network can be end-to-end trained on pairs of images and sequences by the standard back-propagation algorithm, eliminating the procedure of manually labeling all individual characters in training images. This is a weakly supervised learning manner.

2.5 Decoding

The convolutional decoder network is to generate the output sequence of characters from the implicitly learned character-level probability statistics. In the process of unconstrained text recognition (lexicon-free), we use a beam of width

to select the most probable character sequence. As soon as the “” symbol is appended to a hypothesis, it is removed from the beam and is added to the set of complete hypotheses. In order to overcome the bias to short strings, we divide the log-likelihoods of the final hypothesis in beam search by their length .

While in lexicon-driven text recognition, firstly, we select the top hypothesis using beam search, and then calculate the Levenshtein distance between each hypotheses and each item of the lexicon. We choose the one with the shortest distance as the recognition result. We set to be 5 in this work. It should be mentioned that we also develop a simple version of decoding algorithm with prefix tree. We abandon it because we do not find any improvement compared with the forementioned straightforward method.

3 Experiments

In this section we evaluate the proposed SCAN model on four standard scene text recognition benchmarks. Firstly, we give the experiment settings and implementation details. Then, we analyze the design choices in SCAN. For comprehensive performance comparison, SCAN is compared with existing typical methods. For all benchmarks, the performance is measured by word-level accuracy.

3.1 Datasets

We use the synthetic dataset released by  [Jaderberg et al.2014] as training data for all the following experiments. The training set consists of 8 millions images and their corresponding ground truth on text line level. Although we only used the synthetic data to train our model, even without any fine tuning on specific training sets, it works well on real image datasets. We evaluated our scene text recognition system on four popular benchmarks, namely IIIT 5k-word (IIIT5k)  [Mishra et al.2012], Street View Text (SVT)  [Wang et al.2011], ICDAR 2003 (IC03)  [Lucas et al.2005], and ICDAR 2013 (IC13)  [Karatzas et al.2013].

3.2 Implementation Details

During training, all images are normalized to

for parallel computation on GPU. If the proportional width is less than 256, we pad the scaled image to width 256, otherwise, we continue to scale the image to

(this rarely happens because most words are not so long). We do the same normalization on testing images to evaluate the effectiveness of SCAN.

We used 256 hidden units for both convolutional encoders and decoders. We trained networks using Adam  [Kingma and Ba2014]

with the learning rate of 0.0005 and renormalized the gradients if their norm exceeded 0.1. We used mini-batches of 40 images and selected 1% of the training samples for each epoch. Meanwhile, the dropout was set to be 0.5 on both encoder and decoder.

We implemented the model on the platform of Torch 7  

[Collobert et al.2011], and carefully designed our system so that the models can be trained on multiple GPUs simultaneously. Experiments were performed on a workstation with the Intel(R) Xeon(R) E5-2680 CPU, 256GB RAM and four NVIDIA GeForce GTX TITAN X GPUs. It took about only 10 to 15 minutes per epoch, and the training can usually be finished after about 500 epochs222The model can usually converge to relatively good results in only about 150 epochs.. In fact, we also implemented a recurrent sequence learning version of SCAN in private. We found that SCAN in this study is at least 9 times faster than the recurrent model in training speed, which can be attributed to the fully parallelization of the proposed model. SCAN takes only 0.3s to recognize an image on average. We could further improve the speed with better implementation.

3.3 Experimental Results

To our knowledge, SCAN is the first work to adopt convolutional sequence learning network in the field of STR. We find the recommended hyperparameters in

[Gehring et al.2017] do not work well, thus, we investigate the effects of some major parameters of SCAN.

3.3.1 Kernel size and Depth

Table 1 and 2 shows recognition accuracies when we change the number of layers in the encoder or decoder. Here the kernel widths are fixed to be 5 and 7 for layers in the encoder and decoder, respectively. Deeper architectures are particularly beneficial for the encoder but less so for the decoder. Decoder setups with two layers already perform well, whereas for the encoder accuracy keeps increasing steadily to three layers. In fact, we have tried to further increase the number of encoder layers, but find there exists a severe overfitting problem.

Encoder Layer IIIT5k SVT IC03 IC13
1 83.6 81.0 90.1 89.6
2 84.0 81.1 90.3 90.3
3 84.9 82.4 91.4 90.1
Table 1: Effects of encoder layers with 2 decoder layers in terms of accuracy (%).
Decoder Layer IIIT5k SVT IC03 IC13
1 82.9 81.5 90.3 89.0
2 84.9 82.4 91.4 90.1
3 84.2 83.5 90.5 89.4
Table 2: Effects of decoder layers with 3 encoder layers in terms of accuracy (%).
Encoder-Decoder IIIT5k SVT IC03 IC13
5-5 84.6 82.5 90.5 89.4
5-7 84.9 82.4 91.4 90.1
7-7 84.1 82.5 89.9 88.8
Table 3: Effects of kernel width in terms of accuracy (%).

Aside from increasing the depth of the networks, we also change the kernel width. The recognition accuracies with different kernel widths are listed in Table 3. The kernel size of encoders can be referred to the perceptual span across different windows, and the width of 5 performs the best, which is a little larger than the width of a character. The decoder networks can be seen as a language model, it is better to choose large kernel sizes.

3.3.2 Multi-Scale Sliding Window

We investigate two types of model: single-scale model and multi-scale model. The single-scale model has only one input feature map with the window size of , or . While the multi-scale model has three input feature maps, which are firstly extracted with all the three forementioned window sizes and then concatenated together. All the windows are resized to before fed to the convolutional feature extractor. The sliding window is shifted with the step of 4.

Scale-model IIIT5k SVT IC03 IC13
n=1 () 83.7 82.1 89.9 89.3
n=1 () 84.9 82.4 91.4 90.1
n=1 () 84.5 82.1 92.1 90.0
n=3 84.2 85.0 92.1 90.4
Table 4: Effects of scale models in terms of accuracy (%).

The recognition accuracies of models with different scales are shown in Table 4. As for the single-scale model, it can be seen that the window achieve the best performance. The window with large span can deal with more information, which is beneficial for SCAN. However, if the window size is too large (such as ), it may bring many disturbances for feature extraction. The multi-scale model is significantly better than the single one, as it can then take different glimpses to adjust different character fonts and capture more accurate context information.

3.4 Comparative Evaluation

Method IIIT5k SVT IC03 IC13
50 1k None 50 None 50 Full None None
ABBYY [Wang et al.2011] 24.3 - - 35.0 - 56.0 55.0 - -
Wang et al. [Wang et al.2011] - - - 57.0 - 76.0 62.0 - -
Mishra et al. [Mishra et al.2012] 64.1 57.5 - 73.2 - 81.8 67.8 - -
Novikova et al. [Novikova et al.2012] - - - 72.9 - 82.8 - - -
Wang et al. [Wang et al.2012] - - - 70.0 - 90.0 84.0 - -
Bissaco et al. [Bissacco et al.2013] - - - 90.4 78.0 - - - 87.6
Goel et al. [Goel et al.2013] - - - 77.3 - 89.7 - - -
Alsharif & Pineau [Alsharif and Pineau2013] - - - 74.3 - 93.1 88.6 - -
Almazan et al. [Almazán et al.2014] 91.2 82.1 - 89.2 - - - - -
Yao et al. [Yao et al.2014] 80.2 69.3 - 75.9 - 88.5 80.3 - -
R.-Serrano et al. [Rodriguez-Serrano et al.2013] 76.1 57.4 - 70.0 - - - - -
Su & Lu et al. [Su and Lu2014] - - - 83.0 - 92.0 82.0 - -
Gordo [Gordo2015] 93.3 86.6 - 91.8 - - - - -
Jaderberg et al. [Jaderberg et al.2015] 97.1 92.7 - 95.4 80.7* 98.7 98.6 93.1* 90.8*
Jaderberg et al. [Jaderberg et al.2016] 95.5 89.6 - 93.2 71.7 97.8 97.0 89.6 81.8
Shi et al. [Shi et al.2017] 97.8 (5) 95.0 (5) 81.2 (6) 97.5 (1) 82.7 (2) 98.7 (1) 98.0 (1) 91.9 (2) 89.6 (4)
Shi et al. [Shi et al.2016] 96.2 (8) 93.8 (8) 81.9 (4) 95.5 (5) 81.9 (5) 98.3 (3) 96.2 (7) 90.1 (5) 88.6 (6)
Lee et al. [Lee and Osindero2016] 96.8 (7) 94.4 (7) 78.4 (8) 96.3 (2) 80.7 (6) 97.9 (5) 97.0 (3) 88.7 (7) 90.0 (3)
Yin et al. [Yin et al.2017] 98.9 (2) 96.7 (4) 81.6 (5) 95.1 (7) 76.5 (8) 97.7 (7) 96.4 (6) 84.5 (8) 85.2 (8)
Cheng et al. [Cheng et al.2017] (baseline) 98.9 (2) 96.8 (3) 83.7 (3) 95.7 (3) 82.2 (4) 98.5 (2) 96.7 (5) 91.5 (3) 89.4 (5)
Ours (n=1) 98.8 (4) 97.1 (2) 84.9 (1) 95.5 (5) 82.4 (3) 97.8 (6) 97.0 (3) 91.4 (4) 90.1 (2)
Ours (n=3) 99.1 (1) 97.2 (1) 84.2 (2) 95.7 (3) 85.0 (1) 98.3 (3) 97.2 (2) 92.1 (1) 90.4 (1)
Ours (n=1, Residual) 97.8 (5) 94.5 (6) 79.8 (7) 94.7 (8) 77.4 (7) 97.4 (8) 95.7 (8) 89.2 (6) 87.7 (7)
Table 5: Recognition accuracies (%) on four standard scene text datasets. In the second row, 50, 1k and Full denote the lexicon used, and None denotes recognition without language constraints.(* is not lexicon-free in the strict sense, as its outputs are constrained to a 90k dictionary.)

We choose the combination of the parameters that achieve the best performance in the above discussion, and evaluate our model on four public datasets of scene text word recognition. The results are listed in Table 5 with comparison to state-of-the-art methods. It should be mentioned that although Cheng et al.  [Cheng et al.2017] report the best performance with ResNet-based network and focusing attention, they train the model with much more training data (an extra of 4-million pixel-wise labeled word images). Therefore, we only list the baseline performance in their work for fair comparison, which is a ResNet-based structure.

(a) Correct recognition samples
(b) Incorrect recognition samples
Figure 6: Recognition examples of SCAN.

In the lexicon-free case (None), our model outperforms all the other methods in comparison. On IIIT5k, SCAN outperforms prior art  [Cheng et al.2017] by nearly 1%, while on SVT set, it outperforms prior art CRNN  [Shi et al.2017] by significantly 2.3%, indicating a clear improvement in performance.  [Cheng et al.2017] [Shi et al.2017] are both recurrent model based works, while with convolutional sequence learning, SCAN achieves state-of-the-art among the methods using the same data. We observe that IIIT5k contains a lot of irregular text, especially curved text. Although SCAN takes a simple sliding window scheme, because of the powerful feature extractor and sequence learning network, it has an advantage in dealing with irregular text over the complicated RARE model  [Shi et al.2016]. In the constrained lexicon cases, our method consistently outperforms most state-of-the-arts approaches, and in average beats best text readers proposed in  [Shi et al.2017] [Shi et al.2016] [Cheng et al.2017]. The average rank including works  [Shi et al.2017] [Shi et al.2016] [Lee and Osindero2016] [Yin et al.2017] [Cheng et al.2017] and ours shows the superiority of SCAN over all the prior arts. Some recognition examples of SCAN are shown in Fig. 6.

3.5 Visualization

An example of the attention weights for the SCAN model is shown Fig. 7. There exist clear gaps between different characters on the attention heatmap, which reveals that the model can accurately attend on the most relevant sliding windows. Although those recurrent attention model can focus on part of the character  [Shi et al.2016] [Cheng et al.2017], they are unable to locate the boundary of each character. More visualization examples can be found in the supplemental materials.

Figure 7: An example of the attention weights while reading a text image containing the word ”HORTON”. Each point in the attention heatmap corresponds to the center of a sliding window.

4 Conclusion and Future Work

In this paper, we take advantage of the intrinsic characteristics of text recognition, and inspired by human cognition mechanisms in reading texts, we propose a novel method of SCAN for scene text recognition with good interpretation and high performance. Different from the existing approaches, SCAN is an entirely convolutional model based on sliding window and sequence learning, and it acts very similar to the process of human reading. The experimental results on several challenging benchmarks demonstrate the superiority of SCAN over state-of-the-art methods in terms of both the model interpretability and performance. Future work will concentrate on further improvement of the model performance on more challenging datasets.

References

  • [Almazán et al.2014] Jon Almazán, Albert Gordo, Alicia Fornés, and Ernest Valveny. Word spotting and recognition with embedded attributes. IEEE Trans. Pattern Analysis and Machine Intelligence, 36(12):2552–2566, 2014.
  • [Alsharif and Pineau2013] Ouais Alsharif and Joelle Pineau. End-to-end text recognition with hybrid hmm maxout models. arXiv preprint arXiv:1310.1811, 2013.
  • [Bahdanau et al.2015] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proc. ICLR, 2015.
  • [Bissacco et al.2013] Alessandro Bissacco, Mark Cummins, Yuval Netzer, and Hartmut Neven. Photoocr: Reading text in uncontrolled conditions. In Proc. ICCV, pages 785–792, 2013.
  • [Cheng et al.2017] Zhanzhan Cheng, Fan Bai, Yunlu Xu, Gang Zheng, Shiliang Pu, and Shuigeng Zhou. Focusing attention: Towards accurate text recognition in natural images. In Proc. ICCV, pages 5076–5084, 2017.
  • [Collobert et al.2011] Ronan Collobert, Koray Kavukcuoglu, and Clément Farabet.

    Torch7: A MATLAB-like environment for machine learning.

    In Proc. NIPS Workshop of BigLearn, number EPFL-CONF-192376, 2011.
  • [Dalal and Triggs2005] Navneet Dalal and Bill Triggs. Histograms of oriented gradients for human detection. In Proc. CVPR, volume 1, pages 886–893, 2005.
  • [Gehring et al.2017] Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In Proc. ICML, 2017.
  • [Goel et al.2013] Vibhor Goel, Anand Mishra, Karteek Alahari, and CV Jawahar. Whole is greater than sum of parts: Recognizing scene text words. In Proc. 12th Int. Conf. on Document Analysis and Recognition, pages 398–402, 2013.
  • [Gordo2015] Albert Gordo. Supervised mid-level features for word image representation. In Proc. CVPR, pages 2956–2964, 2015.
  • [Graves et al.2009] Alex Graves, Marcus Liwicki, Santiago Fernández, Roman Bertolami, Horst Bunke, and Jürgen Schmidhuber. A novel connectionist system for unconstrained handwriting recognition. IEEE Trans. Pattern Analysis and Machine Intelligence, 31(5):855–868, 2009.
  • [Jaderberg et al.2014] Max Jaderberg, Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Synthetic data and artificial neural networks for natural scene text recognition. arXiv preprint arXiv:1406.2227, 2014.
  • [Jaderberg et al.2015] Max Jaderberg, Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep structured output learning for unconstrained text recognition. In Proc. ICLR, 2015.
  • [Jaderberg et al.2016] Max Jaderberg, Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman.

    Reading text in the wild with convolutional neural networks.

    International Journal of Computer Vision, 116(1):1–20, 2016.
  • [Karatzas et al.2013] Dimosthenis Karatzas, Faisal Shafait, Seiichi Uchida, Masakazu Iwamura, Lluis Gomez i Bigorda, Sergi Robles Mestre, Joan Mas, David Fernandez Mota, Jon Almazan Almazan, and Lluis Pere de las Heras. Icdar 2013 robust reading competition. In Proc. ICDAR, pages 1484–1493, 2013.
  • [Kingma and Ba2014] Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
  • [Lee and Osindero2016] Chen-Yu Lee and Simon Osindero. Recursive recurrent nets with attention modeling for ocr in the wild. In Proc. CVPR, pages 2231–2239, 2016.
  • [Lucas et al.2005] Simon M Lucas, Alex Panaretos, Luis Sosa, Anthony Tang, Shirley Wong, Robert Young, Kazuki Ashida, Hiroki Nagai, Masayuki Okamoto, Hiroaki Yamamoto, et al. Icdar 2003 robust reading competitions: entries, results, and future directions. International journal on document analysis and recognition, 7(2):105–122, 2005.
  • [Mishra et al.2012] Anand Mishra, Karteek Alahari, and CV Jawahar. Scene text recognition using higher order language priors. In Proc. BMVC, 2012.
  • [Novikova et al.2012] Tatiana Novikova, Olga Barinova, Pushmeet Kohli, and Victor Lempitsky. Large-lexicon attribute-consistent text recognition in natural images. In Proc. ECCV, pages 752–765, 2012.
  • [Rodriguez-Serrano et al.2013] Jose A Rodriguez-Serrano, Florent Perronnin, and France Meylan. Label embedding for text recognition. In Proc. BMVC, 2013.
  • [Shi et al.2013] Cunzhao Shi, Chunheng Wang, Baihua Xiao, Yang Zhang, Song Gao, and Zhong Zhang. Scene text recognition using part-based tree-structured character detection. In Proc. CVPR, pages 2961–2968, 2013.
  • [Shi et al.2016] Baoguang Shi, Xinggang Wang, Pengyuan Lyu, Cong Yao, and Xiang Bai. Robust scene text recognition with automatic rectification. In Proc. CVPR, pages 4168–4176, 2016.
  • [Shi et al.2017] Baoguang Shi, Xiang Bai, and Cong Yao. An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition. IEEE Trans. Pattern Analysis and Machine Intelligence, 39(11):2298–2304, 2017.
  • [Su and Lu2014] Bolan Su and Shijian Lu. Accurate scene text recognition based on recurrent neural network. In Proc. ACCV, pages 35–48, 2014.
  • [Sutskever et al.2014] Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Proc. NIPS, pages 3104–3112, 2014.
  • [Wang and Lu2017] Qingqing Wang and Yue Lu. A sequence labeling convolutional network and its application to handwritten string recognition. In Proc. IJCAI, pages 2950–2956, 2017.
  • [Wang et al.2011] Kai Wang, Boris Babenko, and Serge Belongie. End-to-end scene text recognition. In Proc. ICCV, pages 1457–1464, 2011.
  • [Wang et al.2012] Tao Wang, David J Wu, Adam Coates, and Andrew Y Ng. End-to-end text recognition with convolutional neural networks. In Proc. ICPR, pages 3304–3308, 2012.
  • [Wikipedia2017] Wikipedia. Eye movement in reading. https://en.wikipedia.org/wiki/Eye_movement_in_reading, 2017.
  • [Wu et al.2017] Yi-Chao Wu, Fei Yin, and Cheng-Lin Liu. Improving handwritten Chinese text recognition using neural network language models and convolutional neural network shape models. Pattern Recognition, 65:251–264, 2017.
  • [Yao et al.2014] Cong Yao, Xiang Bai, Baoguang Shi, and Wenyu Liu. Strokelets: A learned multi-scale representation for scene text recognition. In Proc. CVPR, pages 4042–4049, 2014.
  • [Ye and Doermann2015] Qixiang Ye and David Doermann. Text detection and recognition in imagery: A survey. IEEE Trans. Pattern Analysis and Machine Intelligence, 37(7):1480–1500, 2015.
  • [Yin et al.2017] Fei Yin, Yi-Chao Wu, Xu-Yao Zhang, and Cheng-Lin Liu. Scene text recognition with sliding convolutional character models. arXiv preprint arXiv:1709.01727, 2017.
  • [Zhu et al.2016] Yingying Zhu, Cong Yao, and Xiang Bai. Scene text detection and recognition: Recent advances and future trends. Frontiers of Computer Science, 10(1):19–36, 2016.

Appendix A Supplementary Material of SCAN

To give a more comprehensive understanding of SCAN (the abbreviation of Sliding Convolutional Attention Network), we further conduct the extended visualization experiments. First, we vividly give a step-by-step introduction of the recognition process in detail. Then, we give more visualization examples to demonstrate the superiority of SCAN.

a.1 An Example of Recognition Process

Figure 8: Sliding window and feature extraction process for the textline image “HAPPINESS”.
(a) The process of emitting the character “A”
(b) The process of emitting the character “N”
Figure 9: The attention mechanism of SCAN based on the input feature sequence.

The SCAN recognition system consists of three major parts, namely a sliding window layer, a convolutional feature extractor, and a convolutional sequence network. Firstly, the sliding window layer splits the textline into overlapped windows. On the top of sliding window, a convolutional feature extractor is built to extract the discriminative features. These two steps are shown in Fig. 8 for the textline image “HAPPINESS”. Then, based on the extracted feature sequences, a convolutional sequence learning network is adopted to map the input to the output result. In Fig. 9(a), the character “A” is emitted according to the most relevant windows when considering the emitted previous characters and the whole feature sequence. Similar case is shown in Fig. 9(b), where the character “N” is emitted. The behavior of SCAN is very similar to the acuity of foveal vision in human reading. The dynamic process of SCAN can be found in https://github.com/nameful/SCAN.

a.2 Visualization of Recognition Results

More visualization examples of the recognition results are shown in Fig. 10, where each one is equipped with a corresponding attention heatmap. Fig. 10(a)

shows some correct recognition samples. We can see that SCAN can not only transcribe texts in slightly blurred or curved images robustly in most cases, but also locate the boundary of each character. Therefore, SCAN can accurately attend on the most relevant windows to give the final recognition results. We find that in some cases (such as the word image “CROFT”), some attention weights far away from the specified character (“C” in this case) also has certain responses in the heatmap. This phenomenon indicates that SCAN may have implicitly modeled the between-character relationship because of the long context information the convolutional model can capture. Moreover, we could make use of some heuristic rules to remove these weights if we need to locate the position of each character precisely, since they are usually restricted to a very small range with relatively low responses.

(a) Correct recognition samples
(b) Incorrect recognition samples. The ground truths of the three images are“STARBUCKS”,“BOOKS” and “CENTRAL”, respectively.
Figure 10: Recognition examples of SCAN.

On the other hand, some incorrect recognition samples are shown in Fig. 10(b). It can be seen that SCAN are still unable to deal with severely blurred or curved word images, although it has powerful feature extractor and sequence learning network. The attention of SCAN is usually drifted in images containing insertion and deletion errors. It is an alternative approach to utilize better structure for feature extraction (such as DenseNet) to enhance the discriminant of features. For those irregular text images, we may first acquire the center curve of the text line by some detection333Nowadays, it is a trend to use direct regression for multi-oriented scene text detection. or curve fitting techniques, and then slide along the curve to obtain the window sequence. In this way, we may further improve the performance of SCAN.