NEURAL NETWORK ARCHITECTURE FOR RECOGNITION OF RUNNING HANDWRITING

  NEURAL NETWORK ARCHITECTURE FOR RECOGNITION OF RUNNING HANDWRITING.doc (Size: 161 KB / Downloads: 0)
Abstract
Handwriting recognition has been a problem that computers are not efficient good at. This is obviously due to the varying writing styles that exist. Today, efficient handwriting recognition is limited to ones using hardware like light pens where in the strokes are directly detected and the character recognized. But if you want to convert a handwritten document to digital text, we have to extract the characters and then recognizing the extracted character. But the problem with this approach is that there are not many algorithms that could efficiently extract characters from a sentence. There fore character recognition using software is still not as efficient as it could be.
In this paper, we suggest the design of software which could do this job of translating handwritten text to digital text. We propose a new approach using which the problem of recognizing handwritten text can be solved. We also provide the implementation details of this software. For the implementation of our idea, we propose a new neural network architecture, which is a modified version of the conventional back propagation network, tailor made for this application. Details including the automatic preprocessing that would be done; the shortcomings, etc are also included under the paper.
Scenario
The scenario in any developing country is almost the same today. The western countries with their superior infrastructure, are making the most of the technology while in countries like ours, technology has been limited to the metropolitans where the infrastructure has been developed. But if we are equal to the developed countries in exploiting these technologies, we need to expand our infrastructure into the rest of our country including villages.
But to this we should first implement a completely computerized way of doing everything. Everything from rations, electricity, grocery, to taxes should be kept track of by computers. This would drastically reduce the speed of processing documents and manpower needed. This has to happen at some point of time, if not immediately, if we are to compete with the developed countries in any means.
As it is obvious, establishing such an infrastructure in a country as huge as ours would require huge resources. The required number of computers, networks etc would be massive. This is one of the main areas of research in which the Indian department of information technology is involved. It is constantly working on producing cheaper computers, components and software.
But even if we do produce such an infrastructure by the year 2020 as is expected, it would take a massive amount of manual work to do the switching or transition to such a system where everything is computerized.
This is so because for over half a century, we have been recording every detail manually, and if we are to switch to a digital means, all these need to be converted into the digital media too. This means more work. Manually feeding all these details into a digital media would take mammoth manpower and time which cannot be practically accomplished. So a solution for this problem would be to computerize this transformation too, by developing software that would recognize handwritten documents and transform it into digital files or databases.
Our Model
The basic design of our software includes a buffer which is of equal size as the input bitmap file. The whole of the file is first scanned into this buffer. All the processing involved in the recognition process is performed on the data present in this buffer. The innovation or the difference in the recognition process is the way these pixels are handled. As explained before in the already existing software, first a raster scan is performed on the bitmap and each character is recognized making them not suitable for recognizing running letters. To avoid this we prefer not to segment the characters before recognizing them.
We accomplish the recognition process as and when the scanning is done. We use two simultaneous scans, a vertical and horizontal one; feed them to two different neural networks.
The key in this is that when a horizontal scan is performed, the pixels are fed into a neural network which is trained to identify the bases of various letters.
Once the base of a letter is identified, the characters, in the order in which they appear in the sentence, are transferred to a second buffer where the sentences are placed. This is where the vertical scan comes into play.
The sentence buffer is scanned vertically and the pixels are fed into the second neural network which identifies the characters based on the pixel pattern. So when each of the pixels is read, it is fed into the neural network which recognizes it at real time. But the output of this is not determined until the character is decided for sure.
The Inspiration
The solution that we proposed is inspired by the lexical analyzers used in compilers. The lexical analyzer typically scans each character of the input string and based on current input, the state transition is made. The transition continues till a predefined final state is reached. The final state that is reached decides what the lexical unit is. This is exactly what we do with the image file containing the handwritten text. We scan each pixel column and based on the pattern so far scanned and the current pixel column the match percentage is calculated for the various character. If a match is found to be good enough, then the recognition is made.
The Problem
The problem here is that during such a real time operation, letters like ‘h’ and ‘b’ could be recognized as ‘l’ before the complete character could be scanned. So there is a need for an extra constraint which would make sure that this kind of real time processing does not end up in wrong results. The constraint here is brought in to the network such that the recognition is based on the character recognized till the previous column of pixels and the current column. That is if a character (c1) has been recognized till the previous column of pixels and if the next few columns of pixels do not take it closer to any other character in terms of the hamming distance, then the corresponding character is recognized. If the next few columns do take it closer to some other character then, the column till which the character (c1) was recognized is kept track of, and then if it starts to deviate from that character then it is still recognized as c1, and the next character starts from the column next to c1. On the contrary, if it takes the recognition extremely close to some other character (c2), then the character is recognized as c2 and not c1. For example, ‘l’ could be c1 and ‘b’ could be c2. In that case, c2 is recognized. If some other character like ‘ ’ were in the following pixels, it might take the letter closer to ‘b’ but starts to deviate there after then it is recognized as l and some other character. Thus the recognition could be performed at real time. Therefore the recognition could be extended to scripts written in cursive form.
Implementation Using Back Propagation Networks
The idea that we proposed can be easily implemented using a conventional back propagation network. The network as usual can have one or two hidden layers. The number of output units is equal to the number of characters present in the language that is being recognized. The number of units in the input layer is equal to the sum of the number of units in the output layer and the maximum height of the character. The input to the network consists of two different sets of data.
One set represents the pattern of the column of pixels that are currently being analyzed. The other set is basically the output that is being fed back into the input layer. The output of the network would represent the percentage match of the pattern so far scanned with the various characters. So when this information is fed back as a part of the input, and the other part being the information on the pattern, then the output depends on both the previously recognized patterns and the current pattern.
Based on this it is decided whether the pattern matches more with the characters or not. Thus when the percentage match exceeds a threshold, then the character is recognized.
But the problem with this implementation is that we would have to create a way to page link the values representing the percentage match with the patterns and the characters that they stand for. Instead of this, we refined the neural network so as to give a new architecture that would perfectly suit the problem in hand.