www.allitebooks.com

Chapter 8
Our targets are integer values between 0 and 26, with each representing a letter of
the alphabet. Neural networks don't usually support multiple values from a single
neuron, instead preferring to have multiple outputs, each with values 0 or 1. We
therefore perform one hot-encoding of the targets, giving us a target array that has
26 outputs per sample, using values near 1 if that letter is likely and near 0 otherwise.
The code is as follows:
from sklearn.preprocessing import OneHotEncoder
onehot = OneHotEncoder()
y = onehot.fit_transform(targets.reshape(targets.shape[0],1))
The library we are going to use doesn't support sparse arrays, so we need to turn
our sparse matrix into a dense NumPy array. The code is as follows:
y = y.todense()
Adjusting our training dataset to our
methodology
Our training dataset differs from our final methodology quite significantly. Our
dataset here is nicely created individual letters, fitting the 20-pixel by 20-pixel image.
The methodology involves extracting the letters from words, which may squash
them, move them away from the center, or create other problems.
Ideally, the data you train your classifier on should mimic the environment it will
be used in. In practice, we make concessions, but aim to minimize the differences
as much as possible.
For this experiment, we would ideally extract letters from actual CAPTCHAs and
label those. In the interests of speeding up the process a bit, we will just run our
segmentation function on the training dataset and return those letters instead.
We will need the resize function from scikit-image, as our sub-images won't
always be 20 pixels by 20 pixels. The code is as follows:
from skimage.transform import resize
From here, we can run our segment_image function on each sample and then resize
them to 20 pixels by 20 pixels. The code is as follows:
dataset = np.array([resize(segment_image(sample)[0], (20, 20)) for
sample in dataset])
[ 171 ]