www.allitebooks.com

Beating CAPTCHAs with Neural Networks
These neurons made their mistake because of the neurons giving them input, but
more specifically due to the weights on the connections between the neuron and its
inputs. We then alter these weights by altering them by a small amount. The amount
of change is based on two aspects: the partial derivative of the error function of
the neuron's individual weights and the learning rate, which is a parameter to the
algorithm (usually set at a very low value). We compute the gradient of the error
of the function, multiply it by the learning rate, and subtract that from our weights.
This is shown in the following example. The gradient will be positive or negative,
depending on the error, and subtracting the weight will always attempt to correct
the weight towards the correct prediction. In some cases, though, the correction will
move towards something called a local optima, which is better than similar weights
but not the best possible set of weights.
This process starts at the output layer and goes back each layer until we reach the
input layer. At this point, the weights on all connections have been updated.
PyBrain contains an implementation of the backprop algorithm, which is called on
the neural network through a trainer class. The code is as follows:
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, training, learningrate=0.01,
weightdecay=0.01)
The backprop algorithm is run iteratively using the training dataset, and each time
the weights are adjusted a little. We can stop running backprop when the error
reduces by a very small amount, indicating that the algorithm isn't improving the
error much more and it isn't worth continuing the training. In theory, we would run
the algorithm until the error doesn't change at all. This is called convergence, but in
practice this takes a very long time for little gain.
Alternatively, and much more simply, we can just run the algorithm a fixed number
of times, called epochs. The higher the number of epochs, the longer the algorithm
will take and the better the results will be (with a declining improvement for each
epoch). We will train for 20 epochs for this code, but trying larger values will
increase the performance (if only slightly). The code is as follows:
trainer.trainEpochs(epochs=20)
After running the previous code, which may take a number of minutes depending
on the hardware, we can then perform predictions of samples in our testing dataset.
PyBrain contains a function for this, and it is called on the trainer instance:
predictions = trainer.testOnClassData(dataset=testing)
[ 174 ]