def test_mnist_28by28(self):
import time
import os
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cross_validation import train_test_split
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import LabelBinarizer
from ann import ANN
# load lecun mnist dataset
X = []
y = []
with open('data/mnist_test_data.txt', 'r') as fd, open('data/mnist_test_label.txt', 'r') as fl:
for line in fd:
img = line.split()
pixels = [int(pixel) for pixel in img]
X.append(pixels)
for line in fl:
pixel = int(line)
y.append(pixel)
X = np.array(X, np.float)
y = np.array(y, np.float)
# normalize input into [0, 1]
X -= X.min()
X /= X.max()
# quick test
#X = X[:1000]
#y = y[:1000]
# for my network
X_test = X
y_test = y #LabelBinarizer().fit_transform(y)
nn = ANN([1,1])
nn = nn.deserialize('28_200000.pickle') # '28_100000.pickle'
predictions = []
for i in range(X_test.shape[0]):
o = nn.predict(X_test[i])
predictions.append(np.argmax(o))
# compute a confusion matrix
print("confusion matrix")
print(confusion_matrix(y_test, predictions))
# show a classification report
print("classification report")
print(classification_report(y_test, predictions))
def test_xor_trainig(self):
print("test_xor_trainig...")
nn = ANN([2, 2, 1])
inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
targets = [[0.0], [1.0], [1.0], [0.0]]
predicts = []
# train
nn.train(40000, inputs, targets)
for i in range(len(targets)):
predicts.append(nn.predict(inputs[i]))
# the prediction for 0,0 and 1,1 should be less than prediction for 0,1 and 1,0
self.assertTrue(predicts[0] < predicts[1], 'xor relation1 not learned')
self.assertTrue(predicts[0] < predicts[2], 'xor relation2 not learned')
self.assertTrue(predicts[3] < predicts[1], 'xor relation3 not learned')
self.assertTrue(predicts[3] < predicts[2], 'xor relation4 not learned')
def anncv(Xtrain, Ytrain, Xtest, Ytest):
inputsize = Xtrain.shape[1]
hiddensize = 12
outputsize = len(classes)
ann = ANN(inputsize,hiddensize,outputsize)
mtrain = len(Ytrain)
# for this example, im only training with the first 12 examples
for n in xrange(400):
for i in xrange(mtrain):
x,y = Xtrain[i],Ytrain[i]
target = np.zeros(len(classes))
target[classes.index(y)] = 1
ann.train(x,target,alpha=0.1,momentum=0.2)
mtest = len(Ytest)
Ypredict = np.zeros(mtest)
for i in xrange(mtest):
x,y = Xtest[i],Ytest[i]
results = ann.predict(x)
prediction = results.argmax()
Ypredict[i] = prediction
return Ypredict
ylb.fit(y)
# split the dataset
X_train, X_test, y_train, y_test = train_test_split(xsc.transform(X), y, random_state=0)
# load nn if exists else train
nn_fname = 'models/nn_iris_3000epochs.pickle'
if os.path.exists(nn_fname):
# load
print('loading the nn')
nn = deserialize(nn_fname)
else:
# train
print('training the nn')
nn = ANN([4, 10, 3])
nn.train(X_train, ylb.transform(y_train), 3000)
serialize(nn, nn_fname)
# predict
preds = np.array([nn.predict(example) for example in X_test])
y_pred = ylb.inverse_transform(preds)
# evaluate
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
# see how long training takes
startTime = time.time()
# train it
nn.train2(30, X_train_l, labels_train_l, 100000, step_cb)
elapsedTime = time.time() - startTime
print("Training took {0} seconds".format(elapsedTime))
# serialize and save the ANN
nn.serialize(nn, serialized_name)
# compute the predictions
predictions = []
for i in range(X_test.shape[0]):
o = nn.predict(X_test[i])
# the inverse of the binarization would be taking the maximum argument index
# ex: [.1 .1 .1 .1 .9 .1 .1 .1 .1 .1] -> 4
# ex: [.1 .1 .1 .1 .1 .1 .1 .9 .1 .1] -> 7
predictions.append(np.argmax(o))
# compute a confusion matrix
print("confusion matrix")
print(confusion_matrix(y_test, predictions))
# show a classification report
print("classification report")
print(classification_report(y_test, predictions))
def test_mnist_8by8_training(self):
print("test_mnist_8by8_training")
import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cross_validation import train_test_split
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import precision_score, recall_score
# import the simplified mnist dataset from scikit learn
digits = load_digits()
# get the input vectors (X is a vector of vectors of type int)
X = digits.data
# get the output vector ( y is a vector of type int)
y = digits.target
# normalize input into [0, 1]
X -= X.min()
X /= X.max()
# split data into training and testing 75% of examples are used for training and 25% are used for testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=123)
# binarize the labels from a number into a vector with a 1 at that index
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
# convert from numpy to normal python list for our simple implementation
X_train_l = X_train.tolist()
labels_train_l = labels_train.tolist()
# create the artificial neuron network with:
# 1 input layer of size 64 (the images are 8x8 gray pixels)
# 1 hidden layer of size 100
# 1 output layer of size 10 (the labels of digits are 0 to 9)
nn = ANN([64, 100, 10])
# see how long training takes
startTime = time.time()
# train it
nn.train(10, X_train_l, labels_train_l)
elapsedTime = time.time() - startTime
print("time took " + str(elapsedTime))
self.assertTrue(elapsedTime < 300, 'Training took more than 300 seconds')
# compute the predictions
predictions = []
for i in range(X_test.shape[0]):
o = nn.predict(X_test[i])
predictions.append(np.argmax(o))
# compute a confusion matrix
# print(confusion_matrix(y_test, predictions))
# print(classification_report(y_test, predictions))
precision = precision_score(y_test, predictions, average='macro')
print("precision", precision)
recall = recall_score(y_test, predictions, average='macro')
print("recall", recall)
self.assertTrue(precision > 0.93, 'Precision must be bigger than 93%')
self.assertTrue(recall > 0.93, 'Recall must be bigger than 93%')
# serialize and save the ANN
nn.serialize(nn, serialized_name)
# plot error over time
#plt.plot(step, train_error, 'b--', step, validation_err, 'gs', t, t**3, 'g^')
#plt.plot(step, train_error, 'b--', step, validation_err, 'g')
plt.plot(steps, train_error, 'b--', label="Training Error")
plt.plot(steps, validation_err, 'g', label="Validation Error")
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.)
plt.title('Training Error vs Validation Error')
plt.show()
# compute the predictions
predictions = []
for i in range(X_test.shape[0]):
o = nn.predict(X_test[i])
# the inverse of the binarization would be taking the maximum argument index
# ex: [.1 .1 .1 .1 .9 .1 .1 .1 .1 .1] -> 4
# ex: [.1 .1 .1 .1 .1 .1 .1 .9 .1 .1] -> 7
predictions.append(np.argmax(o))
# compute a confusion matrix
print("confusion matrix")
print(confusion_matrix(y_test, predictions))
# show a classification report
print("classification report")
print(classification_report(y_test, predictions))
# visualize
show_training_digits(digits)
