# uncomment the following lines to install the required packages
# !pip install tensorflow
# !pip install pandas
# !pip install numpy

import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Load the MNIST dataset, a dataset of handwritten digits
# The MNIST dataset is a dataset of 60,000 28x28 grayscale images of the 10 digits
# Data is split into a training set of 50,000 images and a test set of 10,000 images 
# The training and test data is structured as a 3-dimensional array of instance, image width and image height.
# X_train: is the image data, 50000 images, each element is 28x28 gray scale image
# y_train: is the label data, 50000 labels, each label corresponds to a handwritten digit
# X_test: is the image data, 10000 images, each element is 28x28 gray scale image 
# y_test: is the label data, 10000 labels, each label corresponds to a handwritten digit
mnist = tf.keras.datasets.mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Flatten the input images
# Neural networks expect the input to be a 1D array of numbers
# X_train and X_test are reshaped to 1D array of 784 from 2D array of 28x28
X_train = X_train.reshape(X_train.shape[0], -1)  # X_train.shape[0]: 50000, -1: 784, 28x28
X_test = X_test.reshape(X_test.shape[0], -1) #`X_test.shape[0]: 10000, -1: 784, 28x28`

# Normalize the data
# X_train, X_test are normalized from and integer between 0-255 to a float32 between 0-1
X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255

# Convert the target variable to one-hot encoded vectors
# For each label all elements are 0 except for the index of the number which is 1
# For example, 5 is converted to [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], starting from left counting 0,1,2,3,4,5 in this example
# y_train, y_test are converted to one-hot encoded vectors
# num_classes: 10, number of elements in the one-hot encoded vectors
y_train = tf.keras.utils.to_categorical(y_train, num_classes=10)
y_test = tf.keras.utils.to_categorical(y_test, num_classes=10)

# Define a new Sequential model, for a Neural Network (NN)
# Sequential model, provide by Keras, is a linear stack of layers
# Each layer has exactly one input tensor and one output tensor, a tensor is a multi-dimensional array
# Dense is the regular densely-connected NN layer, each neuron is connected to every neuron in the previous layer
# ... 128: number of neurons in the layer, also called nodes or units; this is a hyperparameter and can be tuned for better performance or accuracy
# ... relu: rectified linear unit, a common choice in neural networks
# ... input_shape: shape of the input data, 
# ... 784: 28x28
# Dense layer with 10 neurons, one for each digit
# ... 10: number of output units
# ... softmax is activation function, it is used to convert the output to a probability distribution
model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(784,)))
model.add(Dense(10, activation='softmax'))

# Compile the model
# loss: loss function to minimize, categorical_crossentropy is a good default for classification
# optimizer: adam is the algorithm to used to minimize the loss function, it combines the advantages of two other extensions of stochastic gradient descent
# metrics: judge the performance of the model, accuracy is appropriate for classification problems 
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model, for a number of epochs, in this case 10
# X_train, y_train: the training data and corresponding labels
# epochs: number of times the model will passed through the model
# batch_size: means to model will be trained on 32 images at a time
# validation_data: is used to monitor the test loss and accuracy during training
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))

# Evaluate the model, the test loss and accuracy
# X_test: test data, the images
# y_test: target data, the labels
# test_loss: scalar test loss, float between 0 and 1, close to 0 is good
# test_acc: scalar test accuracy, float between 0 and 1, close to 1 is good  
test_loss, test_acc = model.evaluate(X_test, y_test)
print('Test loss:', test_loss)
print('Test accuracy:', test_acc)

# This cell is dependent on the previous cell

# uncomment the following lines to install the required packages
# !pip install matplotlib 

import matplotlib.pyplot as plt

# Make predictions on the test set
y_pred = model.predict(X_test)

# Generate a random sample of 25 indices from the range 0 to 9999
indices = np.random.choice(range(10000), size=25, replace=False)

# Setup 25 images and their predicted labels prior to iteration
_, axs = plt.subplots(5, 5, figsize=(14, 14)) # setup 5x5 grid and scale figure
axs = axs.ravel() # convert to 1D array for easy iteration
for i in range(25):
    axs[i].set_title('test {} = {}'.format(indices[i],np.argmax(y_pred[indices[i]]))) # show test, predicted value
    axs[i].imshow(X_test[indices[i]].reshape(28, 28), cmap=plt.cm.gray_r) # show flattened 1D array as 2D array, 28x28
    axs[i].axis('off') # turn of axis

# Show occurs after the loop
plt.show()