Simple classifier on PyBrain and PyQt4 (Python3)

Studying Python3, I ported (as I could) the PyBrain library. I already wrote about this here .

Now I want to play a little with this library. As I said in the previous post, I just started to learn the python, so everything written in this article should not be taken as the Truth. Learning is the way, and it is tortuous.

The task is set before the artificial neural network (INS) is very simple - the classification, namely, the recognition of letters of the Latin alphabet.

It seems to be a classic example, it has already been written about it many times in Habré: “What are artificial neural networks?” , “Neural networks and character recognition” , etc.
But my goal is to study python on the not so simple examples. Those. we learn at once on the complex and unfamiliar. So we will find twice as many rakes, which will allow us to dig into the depths of the language, dealing with "why does not work?".
')
Under habrakat you will find: a description of how to prepare data on PyQt4 , the use of the module argparse , and of course PyBrain !


Having read articles here on Habré and not only, you understand that it is difficult not to write / create / design an INS, but to prepare for it a set of training and test data. Therefore, our task is divided into two subtasks:

• prepare training data;
• design and train ANN.

We will do it in this order. So to speak on the rise.

Data preparation

Technical task

Let's clarify the task: the size of the image with the letter will be, say, 64 by 64 pixels (a total of 4096 entries from the INS).
For this we need to write a generator of these pictures. And we will write it, naturally, in python.
Training data will include:

• lowercase latin letters
• Latin uppercase letters
• letters can be of different sizes (optional)
• the style may be different (different fonts may be used)

Based on this, we will write a generator, to which the parameters are fed to the input:

• a list of letters, for example, abc or fx (range)
• font size for example 40
• font used
• path to the folder where the generated images will be stored

Search method of working with images

To write a generator, we need information on image processing methods in python. Google didn't help us much. I suggested using either the Python Imaging Library - PIL for short, or PyGame .
But that's bad luck. The first is only for python2, and the last release was in 2009. Although on github.com there is its fork under the third python . After reading the manual, I realized that everything is not so simple.
PyGame is a more interesting option, even the manual read it a little longer. I understood that it was necessary to specifically understand the library, but something could not be done with a swoop. And using a microscope for nailing is not an option either. Not for this library is intended.
Googled more. There is pythonmagick, but it is only for UNIX-like systems. And then it dawned on me! PyQt4 !
I am quite familiar with Qt4, I wrote a lot in C ++ / Qt. Yes, this library is like a Swiss knife. You want to open a bottle of beer, you want to cut a beautiful figure from a piece of wood. The main thing - to be able to use a knife. On Qt and stop.
Search in a habr gave us very few information on PyQt . Well, nothing - we'll figure it out.

We write generation and saving of the image

The first thing to do is install PyQt4. With this, I hope the reader will cope - I will not dwell on this. I will go straight to use.
We import the necessary modules, and prepare the “fish” for the program on PyQt4.

#!/usr/bin/env python3 import sys from PyQt4.QtGui import * from PyQt4.Qt import * def main(): app = QApplication([]) # some code here if __name__ == "__main__": sys.exit(main()) 

The line with app = QApplication([]) very important. Do not forget it. Without it, python crashes with SIGFAULT and does not issue any warnings or errors.

Now let's do the filling of the "fish" working logic. Add the save function, which will save the image with the specified parameters.

 def save(png_file, letter = 'A', font = "Arial", size = 40, align = Qt.AlignCenter): img = QImage(64,64, QImage.Format_RGB32) img.fill(Qt.white) p = QPainter(img) p.setPen(Qt.black) p.setFont(QFont(font,size)) p.drawText(img.rect(), align, letter) p.end() img.save(png_file) 

With the parameters of the function - everything is clear. But I will explain the contents.
First, an object of the QImage class is created that allows you to create / process your images in your program. Very powerful and flexible tool. The whole image is 64 by 64 pixels in white.
Then an object of type QPainter is created to which the img reference is passed. This class allows you to draw on the device context or, more precisely, on the outline of any class inherited from QPaintDevice. And just such a class is a QImage.
Set the black pen, font and draw the letter. The default size is 40 (which almost occupies the whole field of the image) and is centered.
Well, then save the image to a file. Everything is simple and obvious.

Finishing touches

It remains small. Parsing command line options.
This can be done in the forehead (with a bunch of if, or by hard-typing the format of the input data), or you can use any advanced modules like getopt or argparse . Last, I think we will study.
Our program at the entrance will receive the following parameters: font, font size and directory where ready-made pictures will fall down.
Alignment while we leave until better times.
Reading this manual as if tells us that we just need to use this piece of code:

  p = argparse.ArgumentParser(description='Symbols image generator') p.add_argument('-f','--font', default='Arial', help='Font name, default=Arial') p.add_argument('-s','--size', type=int, default=40, help='Font size, default=40') p.add_argument('-d','--dir', default='.', help='Output directory, default=current') p.add_argument('letters', help='Array of letters(abc) or range (az)') args = p.parse_args() 

Thus, we describe our parameters, the argparse module will take care of the rest. What I liked was the automatic showing of usage and the automatic generation of help for parameters. Moreover, argparse added one more argument (-h) to our list. For which he thanks a lot. As a real and lazy programmer, I really do not like writing help and other documentation. This is a point in favor of argparse . I will use it more often.
Help for the program we get this:

 usage: gen_pic.py [-h] [-f FONT] [-s SIZE] [-d DIR] letters

 Symbols image generator

 positional arguments:
   letters Array of letters (abc) or range (az)

 optional arguments:
   -h, --help show this help message and exit
   -f FONT, --font FONT Font name, default = Arial
   -s SIZE, --size SIZE Font size, default = 40
   -d DIR, --dir DIR Output directory, default = current

Now we add a check for the existence of the directory path and the expansion of a range of letters. To do this, we use regular expressions. They are not particularly needed in this case, but it is necessary to make the program more impressive! For this, we need the modules os , os.path and re .

  if os.path.exists(args.dir): os.mkdir(args.dir) if re.match('^([az]-[az])|([AZ]-[AZ])$', args.letters): begin = args.letters[0] end = args.letters[2] if (ord(end)-ord(begin))>26: print("Error using letters. Only AZ or az available, not Az.") p.print_help() return letters = [chr(a) for a in range(ord(begin),ord(end)+1)] else: letters = args.letters 

Here you go. It remains to organize the cycle and transfer all the letters in turn to the drawing.

The final touch is to make a binding on top of the save () function and call it saveWrap (). How original, isn't it? Actually, it does nothing supernatural, it simply generates a name for the file based on the parameters passed to the save () function.

In total, the entire generator took us only 55 lines (the code is given at the end of the article). Isn't that great?
And I am sure that the python gurus will surely find a lot of optimization possibilities. But why? Everything works, the code is quite simple and concise. Straight eye rejoices.

INS development

Now we will start work on the ins. First, let's take a look at the capabilities of PyBrain .

At the entrance we have an image (in shades of gray), given by the brightness values ​​of each pixel from 0 to 1.
To begin with, we will make an INS that will recognize a limited set of characters and without different registers. We will teach on data with one font and see how the network recognizes these characters with a different font (test set). Take, for example, the characters A, B, C, D, Z.

Since our network will learn letters, whose images are 64 by 64 pixels in size, the number of entries in our network will be 4096 .
We have only 5 recognizable letters, respectively, and the number of exits from the network is five .
Now the question is: do we need hidden layers? And if so, how much?
I decided to do without hidden layers, so to create a network object I make the following call:

 net = buildNetwork(64 * 64, 5) 

To create one hidden layer of 64 neurons in size and the type of hidden layer of SoftmaxLayer, you need to make the following call:

 net = buildNetwork(64 * 64, 8 * 8, 5, hiddenclass=SoftmaxLayer) 

Unfortunately, the article was told about this function, but no description was given. I will correct this defect.

Those who are interested can choose other options by correcting / uncommenting the call to the buildNetwork () function in the brain.py file.

Training ins

So it's time to start learning. With the help of our program gen_pic.py we generate the necessary letters.
I did it like this:

 ./gen_pic.py -d ./learn -f FreeMono ABCDZ
 ./gen_pic.py -d ./learn -f Times ABCDZ
 ./gen_pic.py -d ./learn -f Arial ABCDZ
 ./gen_pic.py -d ./test -f DroidMono ABCDZ
 ./gen_pic.py -d ./test -f Sans ABCDZ

The process of loading data from the image and converting the RGB color to grayscale let me leave it behind the scenes. There is nothing particularly interesting. To whom it is still terribly interesting how it is done - it can see itself in the brain.py file in the get_data () function.

The learning itself is done in the init_brain () function. The training sample is transferred to this function, the maximum number of epochs for training and optionally the Trainer type, and the function itself returns the object of the already trained network.
Key lines of network creation and training look like this (the full code is provided at the end of the article)

 def init_brain(learn_data, epochs, TrainerClass=BackpropTrainer): ... net = buildNetwork(64 * 64, 5, hiddenclass=LinearLayer) # fill dataset with learn data ds = ClassificationDataSet(4096, nb_classes=5, class_labels=['A', 'B', 'C', 'D', 'Z']) for inp, out in learn_data: ds.appendLinked(inp, [trans[out]]) ... ds._convertToOneOfMany(bounds=[0, 1]) ... trainer = TrainerClass(net, verbose=True) trainer.setData(ds) trainer.trainUntilConvergence(maxEpochs=epochs) return net 

Briefly explain that where.
ClassificationDataSet is a special type of dataset for classification purposes. The source data and the class number of the class (trans [out]) are enough for it to make a sample.
The _convertToOneOfMany () function converts these same class numbers to the values ​​of the output layer.
Next, we transfer the network to the “teacher” and say that we are interested in displaying additional information (the library will print intermediate calculations to the console).
We give the teacher a dataset with a training set (setData ()) and start the training (trainUntilConvergence ()), which will train either until the network converges or until the maximum number of learning epochs is released.

findings

So, the goal is achieved.
The code is written and works. The generator, however, can much more than the network we have built today, in its current form. But there remains an uncultivated field for you, dear% username%! There is something to fix, where to edit, what to rewrite ...

I also add that I have tested two Trainer'a - BackpropTrainer and RPropMinusTrainer .
The speed of the backpropagation algorithm (BackpropTrainer) is poor, converges very slowly. Because of this, learning takes a lot of time.
By changing one line in brain.py, you can look at the work of RPropMinusTrainer . It is much faster and shows quite good results.
I will also add that I didn’t manage to achieve 100% recognition even for a training sample, maybe I had to select the number of layers and the number of neurons in each - I don’t know. There is no practical sense in this program, but for studying Python3 the task is quite good: here you can work with lists, and with dictionaries, and process command line parameters, work with images, regular expressions, work with the file system (modules os and os.path ).

For those who want to play, I will say only one thing - the brain.py program will need some work if you want to change the number of letters or change them for others. Improvements are small and simple.

If you have any questions - write in a personal, but I think that you yourself will understand what, where and how.
There will be time, maybe I will rewrite the prettier code and make it more customizable, I will enter more parameters.

Source codes you can take in the spoilers below.



At this acquaintance with PyBrain today I consider complete. See you again!

upd: at the request of monolithed corrected the regular expression.