05a - Deep Neural Networks (TensorFlow).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Deep Learning with TensorFlow\n",
    "\n",
    "Classical machine learning relies on using statistics to determine relationships between features and labels, and can be very effective for creating predictive models. However, a massive growth in the availability of data coupled with advances in the computing technology required to process it has led to the emergence of new machine learning techniques that mimic the way the brain processes information in a structure called an artificial neural network.\n",
    "\n",
    "TensorFlow is a framework for creating machine learning models, including deep neural networks (DNNs). In this example, we'll use Tensorflow to create a simple neural network that classifies penguins into species based on the length and depth of their culmen (bill), their flipper length, and their body mass.\n",
    "\n",
    "> **Citation**: The penguins dataset used in the this exercise is a subset of data collected and made available by [Dr. Kristen\n",
    "Gorman](https://www.uaf.edu/cfos/people/faculty/detail/kristen-gorman.php)\n",
    "and the [Palmer Station, Antarctica LTER](https://pal.lternet.edu/), a\n",
    "member of the [Long Term Ecological Research\n",
    "Network](https://lternet.edu/).\n",
    "\n",
    "## Explore the dataset\n",
    "\n",
    "Before we start using TensorFlow to create a model, let's load the data we need from the Palmer Islands penguins dataset, which contains observations of three different species of penguin.\n",
    "\n",
    "> **Note**: In reality, you can solve the penguin classification problem easily using classical machine learning techniques without the need for a deep learning model; but it's a useful, easy to understand dataset with which to demonstrate the principles of neural networks in this notebook."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pandas as pd\r\n",
    "\r\n",
    "# load the training dataset (excluding rows with null values)\r\n",
    "penguins = pd.read_csv('data/penguins.csv').dropna()\r\n",
    "\r\n",
    "# Deep Learning models work best when features are on similar scales\r\n",
    "# In a real solution, we'd implement some custom normalization for each feature, but to keep things simple\r\n",
    "# we'll just rescale the FlipperLength and BodyMass so they're on a similar scale to the bill measurements\r\n",
    "penguins['FlipperLength'] = penguins['FlipperLength']/10\r\n",
    "penguins['BodyMass'] = penguins['BodyMass']/100\r\n",
    "\r\n",
    "# The dataset is too small to be useful for deep learning\r\n",
    "# So we'll oversample it to increase its size\r\n",
    "for i in range(1,3):\r\n",
    "    penguins = penguins.append(penguins)\r\n",
    "\r\n",
    "# Display a random sample of 10 observations\r\n",
    "sample = penguins.sample(10)\r\n",
    "sample"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The **Species** column is the label our model will predict. Each label value represents a class of penguin species, encoded as 0, 1, or 2. The following code shows the actual species to which these class labels corrrespond."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "penguin_classes = ['Adelie', 'Gentoo', 'Chinstrap']\r\n",
    "print(sample.columns[0:5].values, 'SpeciesName')\r\n",
    "for index, row in penguins.sample(10).iterrows():\r\n",
    "    print('[',row[0], row[1], row[2],row[3], int(row[4]), ']',penguin_classes[int(row[-1])])"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As is common in a supervised learning problem, we'll split the dataset into a set of records with which to train the model, and a smaller set with which to validate the trained model."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from sklearn.model_selection import train_test_split\r\n",
    "\r\n",
    "features = ['CulmenLength','CulmenDepth','FlipperLength','BodyMass']\r\n",
    "label = 'Species'\r\n",
    "   \r\n",
    "# Split data 70%-30% into training set and test set\r\n",
    "x_train, x_test, y_train, y_test = train_test_split(penguins[features].values,\r\n",
    "                                                    penguins[label].values,\r\n",
    "                                                    test_size=0.30,\r\n",
    "                                                    random_state=0)\r\n",
    "\r\n",
    "print ('Training Set: %d, Test Set: %d \\n' % (len(x_train), len(x_test)))\r\n",
    "print(\"Sample of features and labels:\")\r\n",
    "\r\n",
    "# Take a look at the first 25 training features and corresponding labels\r\n",
    "for n in range(0,24):\r\n",
    "    print(x_train[n], y_train[n], '(' + penguin_classes[y_train[n]] + ')')"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The *features* are the measurements for each penguin observation, and the *label* is a numeric value that indicates the species of penguin that the observation represents (Adelie, Gentoo, or Chinstrap).\n",
    "\n",
    "## Install and import TensorFlow libraries\n",
    "\n",
    "Since we plan to use TensorFlow to create our penguin classifier, we'll need to run the following two cells to install and import the libraries we intend to use.\n",
    "\n",
    "> **Note** *Keras* is an abstraction layer over the base TensorFlow API. In most common machine learning scenarios, you can use Keras to simplify your code."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "!pip install --upgrade tensorflow"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import tensorflow\r\n",
    "from tensorflow import keras\r\n",
    "from tensorflow.keras import models\r\n",
    "from tensorflow.keras.models import Sequential\r\n",
    "from tensorflow.keras.layers import Dense\r\n",
    "from tensorflow.keras import utils\r\n",
    "from tensorflow.keras import optimizers\r\n",
    "\r\n",
    "# Set random seed for reproducability\r\n",
    "tensorflow.random.set_seed(0)\r\n",
    "\r\n",
    "print(\"Libraries imported.\")\r\n",
    "print('Keras version:',keras.__version__)\r\n",
    "print('TensorFlow version:',tensorflow.__version__)"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Prepare the data for TensorFlow\n",
    "\n",
    "We've already loaded our data and split it into training and validation datasets. However, we need to do some further data preparation so that our data will work correctly with TensorFlow. Specifically, we need to set the data type of our features to 32-bit floating point numbers, and specify that the labels represent categorical classes rather than numeric values."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Set data types for float features\r\n",
    "x_train = x_train.astype('float32')\r\n",
    "x_test = x_test.astype('float32')\r\n",
    "\r\n",
    "# Set data types for categorical labels\r\n",
    "y_train = utils.to_categorical(y_train)\r\n",
    "y_test = utils.to_categorical(y_test)\r\n",
    "print('Ready...')"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Define a neural network\n",
    "\n",
    "Now we're ready to define our neural network. In this case, we'll create a network that consists of 3 fully-connected layers:\n",
    "* An input layer that receives an input value for each feature (in this case, the four penguin measurements) and applies a *ReLU* activation function.\n",
    "* A hidden layer that receives ten inputs and applies a *ReLU* activation function.\n",
    "* An output layer that uses a *SoftMax* activation function to generate an output for each penguin species (which represent the classification probabilities for each of the three possible penguin species). Softmax functions produce a vector with probability values that sum to 1."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Define a classifier network\r\n",
    "hl = 10 # Number of hidden layer nodes\r\n",
    "\r\n",
    "model = Sequential()\r\n",
    "model.add(Dense(hl, input_dim=len(features), activation='relu'))\r\n",
    "model.add(Dense(hl, input_dim=hl, activation='relu'))\r\n",
    "model.add(Dense(len(penguin_classes), input_dim=hl, activation='softmax'))\r\n",
    "\r\n",
    "print(model.summary())"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Train the model\n",
    "\n",
    "To train the model, we need to repeatedly feed the training values forward through the network, use a loss function to calculate the loss, use an optimizer to backpropagate the weight and bias value adjustments, and validate the model using the test data we withheld.\n",
    "\n",
    "To do this, we'll apply an Adam optimizer to a categorical cross-entropy loss function iteratively over 50 epochs."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#hyper-parameters for optimizer\r\n",
    "learning_rate = 0.001\r\n",
    "opt = optimizers.Adam(lr=learning_rate)\r\n",
    "\r\n",
    "model.compile(loss='categorical_crossentropy',\r\n",
    "              optimizer=opt,\r\n",
    "              metrics=['accuracy'])\r\n",
    "\r\n",
    "# Train the model over 50 epochs using 10-observation batches and using the test holdout dataset for validation\r\n",
    "num_epochs = 50\r\n",
    "history = model.fit(x_train, y_train, epochs=num_epochs, batch_size=10, validation_data=(x_test, y_test))"
   ],
   "outputs": [],
   "metadata": {
    "scrolled": true,
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "While the training process is running, let's try to understand what's happening:\n",
    "\n",
    "1. In each *epoch*, the full set of training data is passed forward through the network. There are four features for each observation, and four corresponding nodes in the input layer - so the features for each observation are passed as a vector of four values to that layer. However, for efficiency, the feature vectors are grouped into batches; so actually a matrix of multiple feature vectors is fed in each time.\n",
    "2. The matrix of feature values is processed by a function that performs a weighted sum using initialized weights and bias values. The result of this function is then processed by the activation function for the input layer to constrain the values passed to the nodes in the next layer.\n",
    "3. The weighted sum and activation functions are repeated in each layer. Note that the functions operate on vectors and matrices rather than individual scalar values. In other words, the forward pass is essentially a series of nested linear algebra functions. This is the reason data scientists prefer to use computers with graphical processing units (GPUs), since these are optimized for matrix and vector calculations.\n",
    "4. In the final layer of the network, the output vectors contain a probability value for each possible class (in this case, classes 0, 1, and 2). This vector is processed by a *loss function* to determine how far the values calculated by the network are from the actual values - so for example, suppose the output for a Gentoo penguin (class 1) observation is \\[0.3, 0.4, 0.3\\]. The correct prediction should be \\[0.0, 1.0, 0.0\\], so the variance between the predicted and actual values (how far away the each predicted value is from what it should be) is \\[0.3, 0.6, 0.3\\]. This variance is aggregated for each batch and maintained as a running aggregate to calculate the overall level of error (*loss*) incurred by the training data for the epoch. The accuracy (proportion of correct predictions based on the highest probability value in the output vector) for the training data is also calculated.\n",
    "5. At the end of each epoch, the validation data is passed through the network, and its loss and accuracy are also calculated. It's important to do this because it enables us to compare the performance of the model using data on which it was not trained, helping us determine if it will generalize well for new data or if it's *overfitted* to the training data.\n",
    "6. After all the data has been passed forward through the network, the output of the loss function for the *training* data (but <u>not</u> the *validation* data) is passed to the opimizer. The precise details of how the optimizer processes the loss vary depending on the specific optimization algorithm being used; but fundamentally you can think of the entire network, from the input layer to the loss function as being one big nested (*composite*) function. The optimizer applies some differential calculus to calculate *partial derivatives* for the function with respect to each weight and bias value that was used in the network. It's possible to do this efficiently for a nested function due to something called the *chain rule*, which enables you to determine the derivative of a composite function from the derivatives of its inner function and outer functions. You don't really need to worry about the details of the math here (the optimizer does it for you), but the end result is that the partial derivatives tell us about the slope (or *gradient*) of the loss function with respect to each weight and bias value - in other words, we can determine whether to increase or decrease the weight and bias values in order to decrease the loss.\n",
    "7. Having determined in which direction to adjust the weights and biases, the optimizer uses the *learning rate* to determine by how much to adjust them; and then works backwards through the network in a process called *backpropagation* to assign new values to the weights and biases in each layer.\n",
    "8. Now the next epoch repeats the whole training, validation, and backpropagation process starting with the revised weights and biases from the previous epoch - which hopefully will result in a lower level of loss.\n",
    "9. The process continues like this for 50 epochs.\n",
    "\n",
    "## Review training and validation loss\n",
    "\n",
    "After training is complete, we can examine the loss metrics we recorded while training and validating the model. We're really looking for two things:\n",
    "* The loss should reduce with each epoch, showing that the model is learning the right weights and biases to predict the correct labels.\n",
    "* The training loss and validation loss should follow a similar trend, showing that the model is not overfitting to the training data.\n",
    "\n",
    "Let's plot the loss metrics and see:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "%matplotlib inline\r\n",
    "from matplotlib import pyplot as plt\r\n",
    "\r\n",
    "epoch_nums = range(1,num_epochs+1)\r\n",
    "training_loss = history.history[\"loss\"]\r\n",
    "validation_loss = history.history[\"val_loss\"]\r\n",
    "plt.plot(epoch_nums, training_loss)\r\n",
    "plt.plot(epoch_nums, validation_loss)\r\n",
    "plt.xlabel('epoch')\r\n",
    "plt.ylabel('loss')\r\n",
    "plt.legend(['training', 'validation'], loc='upper right')\r\n",
    "plt.show()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## View the learned weights and biases\n",
    "\n",
    "The trained model consists of the final weights and biases that were determined by the optimizer during training. Based on our network model we should expect the following values for each layer:\n",
    "* Layer 1: There are four input values going to ten output nodes, so there should be 4 x 10 weights and 10 bias values.\n",
    "* Layer 2: There are ten input values going to ten output nodes, so there should be 10 x 10 weights and 10 bias values.\n",
    "* Layer 3: There are ten input values going to three output nodes, so there should be 10 x 3 weights and 3 bias values."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for layer in model.layers:\r\n",
    "    weights = layer.get_weights()[0]\r\n",
    "    biases = layer.get_weights()[1]\r\n",
    "    print('------------\\nWeights:\\n',weights,'\\nBiases:\\n', biases)"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Evaluate model performance\n",
    "\n",
    "So, is the model any good? The raw accuracy reported from the validation data would seem to indicate that it predicts pretty well; but it's typically useful to dig a little deeper and compare the predictions for each possible class. A common way to visualize the performance of a classification model is to create a *confusion matrix* that shows a crosstab of correct and incorrect predictions for each class."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Tensorflow doesn't have a built-in confusion matrix metric, so we'll use SciKit-Learn\r\n",
    "import numpy as np\r\n",
    "from sklearn.metrics import confusion_matrix\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "%matplotlib inline\r\n",
    "\r\n",
    "\r\n",
    "class_probabilities = model.predict(x_test)\r\n",
    "predictions = np.argmax(class_probabilities, axis=1)\r\n",
    "true_labels = np.argmax(y_test, axis=1)\r\n",
    "\r\n",
    "# Plot the confusion matrix\r\n",
    "cm = confusion_matrix(true_labels, predictions)\r\n",
    "plt.imshow(cm, interpolation=\"nearest\", cmap=plt.cm.Blues)\r\n",
    "plt.colorbar()\r\n",
    "tick_marks = np.arange(len(penguin_classes))\r\n",
    "plt.xticks(tick_marks, penguin_classes, rotation=85)\r\n",
    "plt.yticks(tick_marks, penguin_classes)\r\n",
    "plt.xlabel(\"Predicted Species\")\r\n",
    "plt.ylabel(\"Actual Species\")\r\n",
    "plt.show()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The confusion matrix should show a strong diagonal line indicating that there are more correct than incorrect predictions for each class.\n",
    "\n",
    "## Save the trained model\n",
    "Now that we have a model we believe is reasonably accurate, we can save its trained weights for use later."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Save the trained model\r\n",
    "modelFileName = 'models/penguin-classifier.h5'\r\n",
    "model.save(modelFileName)\r\n",
    "del model  # deletes the existing model variable\r\n",
    "print('model saved as', modelFileName)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Use the trained model\n",
    "\n",
    "When we have a new penguin observation, we can use the model to predict the species."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Load the saved model\r\n",
    "model = models.load_model(modelFileName)\r\n",
    "\r\n",
    "# CReate a new array of features\r\n",
    "x_new = np.array([[50.4,15.3,20,50]])\r\n",
    "print ('New sample: {}'.format(x_new))\r\n",
    "\r\n",
    "# Use the model to predict the class\r\n",
    "class_probabilities = model.predict(x_new)\r\n",
    "predictions = np.argmax(class_probabilities, axis=1)\r\n",
    "\r\n",
    "print(penguin_classes[predictions[0]])"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Learn more\n",
    "\n",
    "This notebook was designed to help you understand the basic concepts and principles involved in deep neural networks, using a simple Tensorflow example. To learn more about Tensorflow, take a look at the <a href=\"https://www.tensorflow.org/\" target=\"_blank\">Tensorflow web site</a>."
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6 - AzureML",
   "language": "python",
   "name": "python3-azureml"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}