02_using_metrics_in_eager_mode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using metrics in Eager mode\n",
    "----\n",
    "\n",
    "Hello everyone! In this tutorial, we are going to learn how to use various metrics in order to assess the performance of our neural networks when using the Eager mode in TensorFlow. \n",
    "\n",
    "I've played quite a bit with TensorFlow in Eager mode and I love it. The API seems very intuitive to me and everything seems so much easier to build now, compared to when I was using the declarative mode. The main inconvenient that I've found for now (I am using version 1.7) is that _tf.metrics_ is not yet compatible when using the eager mode. Nevertheless, I have constructed several functions that can help you assess the performance of your network whilst still enjoying the awesomeness of building your networks on the fly. \n",
    "\n",
    "### Tutorial steps:\n",
    "----\n",
    "![img](tutorials_graphics/02_flowchart.png)\n",
    "\n",
    "I have chosen to work on three cases:\n",
    "* **Multi-Classification** \n",
    ">For this task, we are going to use the __*accuracy*__, __*confusion matrix*__ and __*average precision*__ and __*recall*__ in order to evaluate the performance of the our model.\n",
    "* **Imbalanced Binary Classification**\n",
    ">When we are dealing with an imbalanced dataset, the accuracy of a model is not a reliable metric. Thus, we will use the __*ROC-AUC*__ score, which seems to be a more appropriate metric for imbalanced problems.\n",
    "* **Regression**\n",
    "> To assess the performance of our regression model, we will be using the $\\boldsymbol{R^2}$ score (coefficient of determination).\n",
    "\n",
    "I believe these cases are diverse enough to help you in any machine learning project you will encounter further. \n",
    "If you would like me to add any extra metrics that are not encountered below, please let me know and I will do my best to add them later on. So, let's get started :)!\n",
    "\n",
    "** TensorFlow version used - 1.7 **\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import useful libraries and enable eager mode\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import TensorFlow and TensorFlow Eager\n",
    "import tensorflow as tf\n",
    "import tensorflow.contrib.eager as tfe\n",
    "\n",
    "# Import functions to generate toy classication problems\n",
    "from sklearn.datasets import load_wine\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.datasets import make_regression\n",
    "\n",
    "# Import numpy for data preprocessing\n",
    "import numpy as np\n",
    "\n",
    "# Import library for plots\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# Import PCA for dimensionality reduction\n",
    "from sklearn.decomposition import PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enable eager mode. Once activated it cannot be reversed! Run just once.\n",
    "tfe.enable_eager_execution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part I: Dataset for multi-classification\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_data = load_wine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of data in the wine_data dictionary:  ['data', 'target', 'target_names', 'DESCR', 'feature_names']\n"
     ]
    }
   ],
   "source": [
    "print('Type of data in the wine_data dictionary: ', list(wine_data.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of classes:  3\n"
     ]
    }
   ],
   "source": [
    "print('Number of classes: ', len(np.unique(wine_data.target)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of our targets:  [59 71 48]\n"
     ]
    }
   ],
   "source": [
    "print('Distribution of our targets: ', np.unique(wine_data.target, return_counts=True)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of features in the dataset:  13\n"
     ]
    }
   ],
   "source": [
    "print('Number of features in the dataset: ', wine_data.data.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Standardize features\n",
    "----\n",
    "The scale of each feature varies a lot as you can see in the cell below. In order to speed up the training, we will normalize each feature to have zero mean and unit standard deviation. This process is called standardization and it is very helpful in the convergence of the neural network. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize dataset\n",
    "wine_data.data = (wine_data.data - np.mean(wine_data.data, axis=0))/np.std(wine_data.data, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard deviation of each feature after standardization:  [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print('Standard deviation of each feature after standardization: ', np.std(wine_data.data, axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Data visualization. Use PCA to reduce the dimensionality to 2D.\n",
    "----\n",
    "We will use PCA, only for visualization purposes. We will be training our neural network using all 13 features. \n",
    "\n",
    "Let's have a look at how these 3 classes are represented in the 2D space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_pca = PCA(n_components=2, random_state=2018).fit_transform(wine_data.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c822607f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_pca[:,0], X_pca[:,1], c=wine_data.target, cmap=plt.cm.spring)\n",
    "plt.xlabel('First PCA component', fontsize=15)\n",
    "plt.ylabel('Second PCA component', fontsize=15)\n",
    "plt.title('Multi-classification problem', fontsize=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so it appears that the classes are easily separable. By the way, I actually tried using PCA before standardizing the features and the pink and yellow classes were overlapping. By standardizing the features before reducing the dimensionality we managed to obtain a much clear boundary between them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's build a two-layers neural network using the TensorFlow Eager API\n",
    "----\n",
    "\n",
    "As you might have noticed, the most convenient way to build models using TensorFlow Eager is with classes. I think that using classes for your models makes it much easier to organize and adding new components to it. You simply define the layers that you're going to use during initialization and use them later on at the predict stage. It makes it easier to read the architecture of the model during the predict stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class two_layer_nn(tf.keras.Model):\n",
    "    def __init__(self, output_size=2, loss_type='cross-entropy'):\n",
    "        super(two_layer_nn, self).__init__()\n",
    "        \"\"\" Define here the layers used during the forward-pass \n",
    "            of the neural network.     \n",
    "            Args:\n",
    "                output_size: int (default=2). \n",
    "                loss_type: string, 'cross-entropy' or 'regression' (default='cross-entropy')\n",
    "        \"\"\"   \n",
    "        # First hidden layer\n",
    "        self.dense_1 = tf.layers.Dense(20, activation=tf.nn.relu)\n",
    "        # Second hidden layer\n",
    "        self.dense_2 = tf.layers.Dense(10, activation=tf.nn.relu)\n",
    "        # Output layer. Unscaled log probabilities\n",
    "        self.dense_out = tf.layers.Dense(output_size, activation=None)     \n",
    "        # Initialize loss type\n",
    "        self.loss_type = loss_type\n",
    "    \n",
    "    def predict(self, input_data):\n",
    "        \"\"\" Runs a forward-pass through the network.     \n",
    "            Args:\n",
    "                input_data: 2D tensor of shape (n_samples, n_features).   \n",
    "            Returns:\n",
    "                logits: unnormalized predictions.\n",
    "        \"\"\"\n",
    "        layer_1 = self.dense_1(input_data)\n",
    "        layer_2 = self.dense_2(layer_1)\n",
    "        logits = self.dense_out(layer_2)\n",
    "        return logits\n",
    "    \n",
    "    def loss_fn(self, input_data, target):\n",
    "        \"\"\" Defines the loss function used during \n",
    "            training.         \n",
    "        \"\"\"\n",
    "        preds = self.predict(input_data)\n",
    "        if self.loss_type=='cross-entropy':\n",
    "            loss = tf.losses.sparse_softmax_cross_entropy(labels=target, logits=preds)\n",
    "        else:\n",
    "            loss = tf.losses.mean_squared_error(target, preds)\n",
    "        return loss\n",
    "    \n",
    "    def grads_fn(self, input_data, target):\n",
    "        \"\"\" Dynamically computes the gradients of the loss value\n",
    "            with respect to the parameters of the model, in each\n",
    "            forward pass.\n",
    "        \"\"\"\n",
    "        with tfe.GradientTape() as tape:\n",
    "            loss = self.loss_fn(input_data, target)\n",
    "        return tape.gradient(loss, self.variables)\n",
    "    \n",
    "    def fit(self, input_data, target, optimizer, num_epochs=500, \n",
    "            verbose=50, track_accuracy=True):\n",
    "        \"\"\" Function to train the model, using the selected optimizer and\n",
    "            for the desired number of epochs. It also stores the accuracy\n",
    "            of the model after each epoch.\n",
    "        \"\"\"   \n",
    "        \n",
    "        if track_accuracy:\n",
    "            # Initialize list to store the accuracy of the model\n",
    "            self.hist_accuracy = []     \n",
    "            # Initialize class to compute the accuracy metric\n",
    "            accuracy = tfe.metrics.Accuracy()\n",
    "\n",
    "        for i in range(num_epochs):\n",
    "            # Take a step of gradient descent\n",
    "            grads = self.grads_fn(input_data, target)\n",
    "            optimizer.apply_gradients(zip(grads, self.variables))\n",
    "            if track_accuracy:\n",
    "                # Predict targets after taking a step of gradient descent\n",
    "                logits = self.predict(X)\n",
    "                preds = tf.argmax(logits, axis=1)\n",
    "                # Compute the accuracy\n",
    "                accuracy(preds, target)\n",
    "                # Get the actual result and add it to our list\n",
    "                self.hist_accuracy.append(accuracy.result())\n",
    "                # Reset accuracy value (we don't want to track the running mean accuracy)\n",
    "                accuracy.init_variables()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy metric\n",
    "----\n",
    "To assess the performance of our model using the accuracy metric, we will be using the 'tfe.metrics.Accuracy' class. This metric is really useful when training a model in batches, as it computes the mean accuracy across batches each time it is called. As we train our model with the entire dataset at each step, we will be resetting this metric, as we do not want it to track the running mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create input features and targets dataset. Transfer data from numpy to tensors.\n",
    "X = tf.constant(wine_data.data)\n",
    "y = tf.constant(wine_data.target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define optimizer\n",
    "optimizer = tf.train.GradientDescentOptimizer(5e-1)\n",
    "\n",
    "# Initialize model \n",
    "model = two_layer_nn(output_size=3)\n",
    "\n",
    "# Select here the number of epochs\n",
    "num_epochs = 5\n",
    "\n",
    "# Train the model with gradient descent\n",
    "model.fit(X, y, optimizer, num_epochs=num_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c7c5731d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(num_epochs), model.hist_accuracy);\n",
    "plt.xlabel('Epoch number', fontsize=15);\n",
    "plt.ylabel('Accuracy', fontsize=15);\n",
    "plt.title('Training accuracy history', fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion matrix\n",
    "----\n",
    "Visualizing the confusion matrix after you finished training the algorithm is a great way to give you global overview on the performance of your network. TensorFlow has a built-in function to compute the confusion matrix and fortunately it is compatible with eager mode. So let's visualize the confusion matrix of this dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the predictions on the entire dataset\n",
    "logits = model.predict(X)\n",
    "preds = tf.argmax(logits, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix: \n",
      " [[56  3  0]\n",
      " [ 2 66  3]\n",
      " [ 0  1 47]]\n"
     ]
    }
   ],
   "source": [
    "# Print confusion matrix\n",
    "conf_matrix = tf.confusion_matrix(y, preds, num_classes=3)\n",
    "print('Confusion matrix: \\n', conf_matrix.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The diagonal matrix shows the true positives whilst the lower and upper bound of the matrix shows the false positives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precision score\n",
    "----\n",
    "The confusion matrix computed above makes it extremely easy to compute the mean average precision. I will implement a function below, which computes it automatically for you. You can also specify the weights of each class. For example, maybe the precision for class 2 is more important for you for some reason."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def precision(labels, predictions, weights=None):\n",
    "    conf_matrix = tf.confusion_matrix(labels, predictions, num_classes=3)\n",
    "    tp_and_fp = tf.reduce_sum(conf_matrix, axis=0)\n",
    "    tp = tf.diag_part(conf_matrix)\n",
    "    precision_scores = tp/(tp_and_fp)\n",
    "    if weights:\n",
    "        precision_score = tf.multiply(precision_scores, weights)/tf.reduce_sum(weights)\n",
    "    else:\n",
    "        precision_score = tf.reduce_mean(precision_scores)        \n",
    "    return precision_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average precision:  0.9494581280788177\n"
     ]
    }
   ],
   "source": [
    "precision_score = precision(y, preds, weights=None)\n",
    "print('Average precision: ', precision_score.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recall score\n",
    "----\n",
    "The average recall can be computed very similarly with the precision. Instead of summing the columns, we are going to sum the rows in order to get the total number of true positives and false negatives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recall(labels, predictions, weights=None):\n",
    "    conf_matrix = tf.confusion_matrix(labels, predictions, num_classes=3)\n",
    "    tp_and_fn = tf.reduce_sum(conf_matrix, axis=1)\n",
    "    tp = tf.diag_part(conf_matrix)\n",
    "    recall_scores = tp/(tp_and_fn)\n",
    "    if weights:\n",
    "        recall_score = tf.multiply(recall_scores, weights)/tf.reduce_sum(weights)\n",
    "    else:\n",
    "        recall_score = tf.reduce_mean(recall_scores)        \n",
    "    return recall_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average precision:  0.9526322246094269\n"
     ]
    }
   ],
   "source": [
    "recall_score = recall(y, preds, weights=None)\n",
    "print('Average precision: ', recall_score.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part II: Imbalanced binary classification\n",
    "----\n",
    "When you'll start working with real datasets, you will quickly come to notice that most of the problems are kinda imbalanced. For example, anomaly detection problems are severely imbalanced given the proportion of anomalous samples in comparison with the normal ones. In these cases, a more suitable metric to assess the performance of your network is the ROC-AUC score. So, let's build our imbalanced dataset and start working on it :)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = make_classification(n_samples=1000, n_features=2, n_informative=2, \n",
    "                           n_redundant=0, n_classes=2, n_clusters_per_class=1,\n",
    "                           flip_y=0.1, class_sep=4, hypercube=False, \n",
    "                           shift=0.0, scale=1.0, random_state=2018)\n",
    "\n",
    "# Reduce the number of samples with target 1\n",
    "X = np.vstack([X[y==0], X[y==1][:50]])\n",
    "y = np.hstack([y[y==0], y[y==1][:50]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing the dataset\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c7c44a2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X[:,0], X[:,1], c=y, cmap=plt.cm.winter)\n",
    "plt.xlabel('First feature', fontsize=15)\n",
    "plt.ylabel('Second feature', fontsize=15)\n",
    "plt.title('Imbalanced classification example', fontsize=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will be using the same neural network architecture. We just have to initialize the model with num_classes=2, as we're working with a binary classification problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy arrays to tensors\n",
    "X = tf.constant(X)\n",
    "y = tf.constant(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's train the model just for a few epochs, in order to avoid overfitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define optimizer\n",
    "optimizer = tf.train.GradientDescentOptimizer(5e-1)\n",
    "\n",
    "# Initialize model \n",
    "model = two_layer_nn(output_size=2)\n",
    "\n",
    "# Select here the number of epochs\n",
    "num_epochs = 5\n",
    "\n",
    "# Train the model with gradient descent\n",
    "model.fit(X, y, optimizer, num_epochs=num_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to compute the ROC-AUC score\n",
    "----\n",
    "To compute the ROC-AUC score, we will use the same methodology as in *tf.metric.auc*. For each probability threshold, we will be computing the number of *true positives*, *true negatives*, *false positives* and *false negatives*. After computing these statistics, we can compute the true positive rate and false positive rate for each probability threshold. \n",
    "\n",
    "To approximate the area under the ROC curve, we will be using *Riemann sums* and the *trapezoidal rule*. If you would like to find more info on this you can have look [here](https://www.khanacademy.org/math/ap-calculus-ab/ab-accumulation-riemann-sums/ab-midpoint-trapezoid/a/understanding-the-trapezoid-rule)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROC-AUC Function\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roc_auc(labels, predictions, thresholds, get_fpr_tpr=True):\n",
    "    tpr = []\n",
    "    fpr = []\n",
    "    for th in thresholds:    \n",
    "        # Compute number of true positives\n",
    "        tp_cases = tf.where((tf.greater_equal(predictions, th)) & \n",
    "                            (tf.equal(labels, 1)))\n",
    "        tp = tf.size(tp_cases)\n",
    "        \n",
    "        # Compute number of true negatives\n",
    "        tn_cases = tf.where((tf.less(predictions, th)) & \n",
    "                            (tf.equal(labels, 0)))\n",
    "        tn = tf.size(tn_cases)\n",
    "        \n",
    "        # Compute number of false positives\n",
    "        fp_cases = tf.where((tf.greater_equal(predictions, th)) & \n",
    "                            (tf.equal(labels,0)))\n",
    "        fp = tf.size(fp_cases)\n",
    "        \n",
    "        # Compute number of false negatives\n",
    "        fn_cases = tf.where((tf.less(predictions, th)) & \n",
    "                            (tf.equal(labels,1)))\n",
    "        fn = tf.size(fn_cases)\n",
    "        \n",
    "        # Compute True Positive Rate for this threshold\n",
    "        tpr_th = tp/(tp + fn)\n",
    "        \n",
    "        # Compute the False Positive Rate for this threshold\n",
    "        fpr_th = fp/(fp + tn)\n",
    "        \n",
    "        # Append to the entire True Positive Rate list\n",
    "        tpr.append(tpr_th)\n",
    "        \n",
    "        # Append to the entire False Positive Rate list\n",
    "        fpr.append(fpr_th)\n",
    "        \n",
    "    # Approximate area under the curve using Riemann sums and the trapezoidal rule\n",
    "    auc_score = 0\n",
    "    for i in range(0, len(thresholds)-1):\n",
    "        height_step = tf.abs(fpr[i+1]-fpr[i])\n",
    "        b1 = tpr[i]\n",
    "        b2 = tpr[i+1]\n",
    "        step_area = height_step*(b1+b2)/2\n",
    "        auc_score += step_area\n",
    "    return auc_score, fpr, tpr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the ROC-AUC score of our trained model and plot the ROC curve\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More thresholds means higher granularity for the area under the curve approximation\n",
    "# Feel free to experiment with the number of thresholds\n",
    "num_thresholds = 1000 \n",
    "thresholds = tf.lin_space(0.0, 1.0, num_thresholds).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply Softmax on our predictions as the output of the model is unnormalized\n",
    "# Select the predictions of our positive class (the class with less samples)\n",
    "preds = tf.nn.softmax(model.predict(X))[:,1] \n",
    "\n",
    "# Compute the ROC-AUC score and get the TPR and FPR of each threshold\n",
    "auc_score, fpr_list, tpr_list = roc_auc(y, preds, thresholds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC-AUC score of the model:  0.93493986\n"
     ]
    }
   ],
   "source": [
    "print('ROC-AUC score of the model: ', auc_score.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c7c41f550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(fpr_list, tpr_list, label='AUC score: %.2f' %auc_score);\n",
    "plt.xlabel('False Positive Rate', fontsize=15);\n",
    "plt.ylabel('True Positive Rate', fontsize=15);\n",
    "plt.title('ROC curve');\n",
    "plt.legend(fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part III: Dataset for regression\n",
    "---\n",
    "Our final dataset is created for a simple regression task. In the previous two problems, the output of the network represented the class the sample belongs to. Here the output of the network is continuous, a real number. \n",
    "\n",
    "Our input dataset consists only of one feature, to keep things simple and easy to visualize. The target y is a vector of real numbers.\n",
    "\n",
    "Let's create our toy dataset :)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = make_regression(n_samples=100, n_features=1, n_informative=1, noise=30, \n",
    "                       random_state=2018)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the input feature and target\n",
    "----\n",
    "To get a better glimpse on the problem we're working on, let's plot the input feature with regards to the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c7c24f6d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X, y);\n",
    "plt.xlabel('Input', fontsize=15);\n",
    "plt.ylabel('Target', fontsize=15);\n",
    "plt.title('Toy regression problem', fontsize=15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy arrays to tensors\n",
    "X = tf.constant(X)\n",
    "y = tf.constant(y)\n",
    "y = tf.reshape(y, [-1,1]) # change from row vector to column vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Neural network for regression task\n",
    "----\n",
    "We can re-use the two-layer neural network created above. As we only need to predict one real number, the output size of the network is 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to redefine our loss function, as we cannot continue using the softmax cross-entropy loss. Instead, we will be using the mean squared error loss function. We will also define a new optimizer, with a smaller learning rate than the previous one. \n",
    "\n",
    "Feel free to play here with the number of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define optimizer\n",
    "optimizer = tf.train.GradientDescentOptimizer(1e-4)\n",
    "\n",
    "# Initialize model \n",
    "model = two_layer_nn(output_size=1, loss_type='regression')\n",
    "\n",
    "# Select here the number of epochs\n",
    "num_epochs = 300\n",
    "\n",
    "# Train the model with gradient descent\n",
    "model.fit(X, y, optimizer, num_epochs=num_epochs, \n",
    "          track_accuracy=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing the $R^2$ score (coefficient of determination)\n",
    "----\n",
    "If you ever worked on a regression problem, you probably already heard about this score.\n",
    "\n",
    "This metric computes the percentage of variability between the input features and the target, that is explained by our model. The range of values for the $R^2$ score is between 0 and 1. An $R^2$ score of 1 means that the model makes perfect predictions. An $R^2$ score of 0 is obtained by always predicting the mean of the targets y. \n",
    "\n",
    "It is possible to obtain negative values for $R^2$. In this case, it means that our model makes worse predictions than a model which always predicts the mean of the target variable. \n",
    "\n",
    "As this metric is not readily available in TensorFlow 1.5, when running in eager mode, I have created a small function for it, in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2 score:  0.8249999999348803\n"
     ]
    }
   ],
   "source": [
    "# Compute the R2 score\n",
    "def r2(labels, predictions):\n",
    "    mean_labels = tf.reduce_mean(labels)\n",
    "    total_sum_squares = tf.reduce_sum((labels-mean_labels)**2)\n",
    "    residual_sum_squares = tf.reduce_sum((labels-predictions)**2)\n",
    "    r2_score = 1 - residual_sum_squares/total_sum_squares\n",
    "    return r2_score\n",
    "\n",
    "preds = model.predict(X)\n",
    "r2_score = r2(y, preds)\n",
    "print('R2 score: ', r2_score.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing the line of best fit\n",
    "----\n",
    "To visualize the line of best fit of our neural network, we simply take the linear space between X_min and X_max. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create datapoints between X_min and X_max to visualize the line of best fit\n",
    "X_best_fit = np.arange(X.numpy().min(), X.numpy().max(), 0.001)[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predictions on X_best_fit\n",
    "preds_best_fit = model.predict(X_best_fit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3c7c21c470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X.numpy(), y.numpy()); # Original datapoints\n",
    "plt.plot(X_best_fit, preds_best_fit.numpy(), color='k',\n",
    "         linewidth=6, label='$R^2$ score: %.2f' %r2_score) # Our predictions\n",
    "plt.xlabel('Input', fontsize=15);\n",
    "plt.ylabel('Target', fontsize=15);\n",
    "plt.title('Toy regression problem', fontsize=15);\n",
    "plt.legend(fontsize=15);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}