def main():
# Part 1. Complete the Perceptron.
# --------------------------------
# The program begins by creating a perceptron
# to classify only 7's.
for _i in range(1):
# Variable number to predict saved as soon as
# the loop starts
NUMBER_TO_PREDICT = 7
# Quickly load data from the .npz file.
mnist_data = np.load("mnist_scaled.npz")
# Cool, so using the load_mnist script I now have
# the data as an easily accessible .npz file, no
# massive load times. Hoorah!
#
# So using the object as a dictionary I just grab the
# the data that is required.
X_train = mnist_data['X_train']
X_test = mnist_data['X_test']
y_train = mnist_data['y_train']
y_test = mnist_data['y_test']
# print(X_train.shape)
# I've got my wee one hot encoding function working
# so lets create training sets for the number 7.
y_train_seven = one_hot_label(y_train, NUMBER_TO_PREDICT)
y_test_seven = one_hot_label(y_test, NUMBER_TO_PREDICT)
# Use my wee visualise function to confirm the one hot
# encoding has worked. I know 15 is a 7
for _ in range(3):
visualise_number(X_train[_], y_train[_])
# The plot and label both correspond to a seven, so
# lets check my one hot encoding.
print(y_train_seven[15])
# Good, the terminal print out confirms the one hot encoding
# Now lets instanitaite a classifier and train it.
seven_clf = Perceptron(id=NUMBER_TO_PREDICT)
print(f"[+] Training Classifier on {seven_clf.id}'s...")
seven_clf.fit(X_train, y_train_seven)
# Now I test on the first number, which is a 7
pred_seven = seven_clf.predict(X_test[0])
# Great, my perceptron, predicts well, now lets
# iterate over the whole dataframe and make
# predictions yo!
full_pred_list = seven_clf.retn_prediction_list(X_test)
print(
f"\n\tPerceptron Accuracy Predicting {seven_clf.id}'s: {metrics.accuracy_score(full_pred_list, y_test_seven) * 100}%"
)
# Part 2. Implement Batch Learning
# --------------------------------
# Now I use the newly created .batch_fit() method to train the another
# classifier to predict 7's.
batch_perc = Perceptron(id='Batch', eta=0.01, max_iter=50)
batch_perc.fit_batch(X_train, y_train_seven)
print(
"\n[+] Batch Training Classifier on 7's with 0.01 eta and 50 max iter\n"
)
batch_full_list = batch_perc.retn_prediction_list(X_test)
print(
f"\tBatch Perceptron Accuracy Predicting {NUMBER_TO_PREDICT}'s: {metrics.accuracy_score(batch_full_list, y_test_seven) * 100}%\n"
)
# Part 3. Use Multiple Nodes to Classify every Digit.
# --------------------------------------------------
# First I instantiate an instance of my Multi Layer Perceptron
# object. I pass this object the full training set plus the labels.
print('[+] Implementing Multi Layer Perceptron using Sigmoid Function\n')
mlp = MultiLayerPerceptron(10, X_train, y_train)
# Using the in-built fit method, the MLP will create and train
# 10 individual perceptrons and store them inside a dictionary.
mlp.fit()
print("\t[+] Testing Accuracy of Singular Models in MLP...\n")
# The following snippet simply tests each of the perceptrons
# held by the MLP, using the full test set, and prints the
# accuracy of each one indivdually.
for num, model in mlp.inputs.items():
full_pred = model.retn_prediction_list(X_test)
y_ = one_hot_label(y_test, num)
p_list = model.convert_prediction(full_pred)
print(
f"\t\t[+] Perceptron {model.id} Accuracy: {metrics.accuracy_score(p_list, y_) * 100}%\n"
)
# Next up I test the MLP by asking it to make predictions over the
# whole testing set, and print the accuracy.
print(f"\t[+] Testing MLP Predict Method\n")
mlp_pred = []
for _ in range(len(y_test)):
p = mlp.predict(X_test[_])
mlp_pred.append(float(p))
print(
f"\t\tMLP Accuracy: {metrics.accuracy_score(mlp_pred, y_test) * 100}%\n"
)
# Here I print out the first twenty predictions along with their actual
# labels.
print(f"[+] Predicting First Twenty Test Instances...\n")
for _ in range(20):
print(f"\tTesting Instance {_}.\n")
print(f"\tActual Number: {y_test[_]}")
p = mlp.predict(X_test[_])
print(f"\tPredicted Number: {p}\n")
print("----------------------------")
print('\n\n')
# Part 4. Implement A Sigmoid Activation
# --------------------------------------
# By simply adding a parameter to the methods in the perceptron
# object (set by default to 'step') I can make the model train
# and predict using the SIgmoid Activation function.
print("[+] Testing Single Perceptron Trained on Sigmoid")
sigmoid_perceptron = Perceptron(eta=0.01, max_iter=100)
sigmoid_perceptron.fit(X_train, y_train_seven, func='sig')
# Lets test a 7's with sigmoid
sigmoid_full_pred = sigmoid_perceptron.retn_prediction_list(X_test,
func='sig')
sigmoid_pred_list = sigmoid_perceptron.convert_prediction(
sigmoid_full_pred)
print(
f"[+] Sigmoid Activation Accuracy Predicting 7's: {metrics.accuracy_score(sigmoid_pred_list, y_test_seven) * 100}%\n"
)
# Part 5. Print the data to the screen and the weights.
# First I iterate over the first five instances in the test set,
# print them to screen and use a seven classifer to make a
# prediction on them.
for _ in range(5):
pred = seven_clf.predict(X_test[_])
visualise_number_prediction(X_test[_], y_test[_], pred, 7)
# And finally I plot the weights of the '7' classifier to the screen
seven_clf.weight_matrix()
sigmoid_perceptron.weight_matrix()
batch_perc.weight_matrix()
# And just for completeness I wrote the custom accuracy function.
print("[+] DOuble Checking Accuracy Using Custom Method")
print(f"\tStep Function Perceptron Seven Classifier")
seven_clf.accuracy_scores(full_pred_list, y_test_seven)
print("\tSigmoid Perceptron Seven Classifier\n")
sigmoid_perceptron.accuracy_scores(sigmoid_pred_list, y_test_seven)
