www.allitebooks.com

Chapter 11
Finally, we create Theano-based functions that perform this training and also obtain
the output of the network for testing purposes:
import theano
train = theano.function([net_input, true_output], loss,
updates=updates)
get_output = theano.function([net_input], net_output)
We can then call our train function, on our training data, to perform one iteration
of training the network. This involves taking each sample, computing the predicted
class of it, comparing those predictions to the expected classes, and updating
the weights to minimize the loss function. We then perform this 1,000 times,
incrementally training our network over those iterations:
for n in range(1000):
train(X_train, y_train)
Next, we can evaluate by computing the F-score on the outputs. First, we obtain
those outputs:
y_output = get_output(X_test)
Note that get_output is a Theano function we obtained from our
neural network, which is why we didn't need to add our network as a
parameter to this line of code.
This result, y_output, is the activation of each of the neurons in the final output
layer. The actual prediction itself is created by finding which neuron has the
highest activation:
import numpy as np
y_pred = np.argmax(y_output, axis=1)
Now, y_pred is an array of class predictions, like we are used to in classification
tasks. We can now compute the F-score using these predictions:
from sklearn.metrics import f1_score
print(f1_score(y_test, y_pred))
The result is impressively perfect—1.0! This means all the classifications were
correct in the test data: a great result (although this is a simpler dataset).
As we can see, while it is possible to develop and train a network using just Lasagne,
it can be a little awkward. To address this, we will be using nolearn, which is a
package that further wraps this process in code that is conveniently convertible with
the scikit-learn API.
[ 253 ]