Tutorials/CNTK_101_LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# CNTK 101: Logistic Regression and ML Primer\n",
    "\n",
    "This tutorial is targeted to individuals who are new to CNTK and to machine learning. In this tutorial, you will train a simple yet powerful machine learning model that is widely used in industry for a variety of applications. The model trained below scales to massive data sets in the most expeditious manner by harnessing computational scalability leveraging the computational resources you may have (one or more CPU cores, one or more GPUs, a cluster of CPUs or a cluster of GPUs), transparently via the CNTK library.\n",
    "\n",
    "The following notebook uses Python APIs. If you are looking for this example in BrainScript, please look [here](https://github.com/Microsoft/CNTK/tree/v2.0/Tutorials/HelloWorld-LogisticRegression). \n",
    "\n",
    "## Introduction\n",
    "\n",
    "**Problem**:\n",
    "A cancer hospital has provided data and wants us to determine if a patient has a fatal [malignant][] cancer vs. a benign growth. This is known as a classification problem. To help classify each patient, we are given their age and the size of the tumor. Intuitively, one can imagine that younger patients and/or patients with small tumors are less likely to have a malignant cancer. The data set simulates this application: each observation is a patient represented as a dot (in the plot below), where red indicates malignant and blue indicates benign. Note: This is a toy example for learning; in real life many features from different tests/examination sources and the expertise of doctors would play into the diagnosis/treatment decision for a patient.\n",
    "[malignant]: https://en.wikipedia.org/wiki/Malignancy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://www.cntk.ai/jup/cancer_data_plot.jpg\" width=\"400\" height=\"400\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 1\n",
    "Image(url=\"https://www.cntk.ai/jup/cancer_data_plot.jpg\", width=400, height=400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Goal**:\n",
    "Our goal is to learn a classifier that can automatically label any patient into either the benign or malignant categories given two features (age and tumor size). In this tutorial, we will create a linear classifier, a fundamental building-block in deep networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://www.cntk.ai/jup/cancer_classify_plot.jpg\" width=\"400\" height=\"400\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 2\n",
    "Image(url= \"https://www.cntk.ai/jup/cancer_classify_plot.jpg\", width=400, height=400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the figure above, the green line represents the model learned from the data and separates the blue dots from the red dots. In this tutorial, we will walk you through the steps to learn the green line. Note: this classifier does make mistakes, where a couple of blue dots are on the wrong side of the green line. However, there are ways to fix this and we will look into some of the techniques in later tutorials. \n",
    "\n",
    "**Approach**: \n",
    "Any learning algorithm typically has five stages. These are Data reading, Data preprocessing, Creating a model, Learning the model parameters, and Evaluating the model (a.k.a. testing/prediction). \n",
    "\n",
    ">1. Data reading: We generate simulated data sets with each sample having two features (plotted below) indicative of the age and tumor size.\n",
    ">2. Data preprocessing: Often, the individual features such as size or age need to be scaled. Typically, one would scale the data between 0 and 1. To keep things simple, we are not doing any scaling in this tutorial (for details look here: [feature scaling][]).\n",
    ">3. Model creation: We introduce a basic linear model in this tutorial. \n",
    ">4. Learning the model: This is also known as training. While fitting a linear model can be done in a variety of ways ([linear regression][]), in CNTK we use Stochastic Gradient Descent a.k.a. [SGD][].\n",
    ">5. Evaluation: This is also known as testing, where one evaluates the model on data sets with known labels (a.k.a. ground-truth) that were never used for training. This allows us to assess how a model would perform in real-world (previously unseen) observations.\n",
    "\n",
    "## Logistic Regression\n",
    "[Logistic regression][] is a fundamental machine learning technique that uses a linear weighted combination of features and generates the probability of predicting different classes. In our case, the classifier will generate a probability in [0,1] which can then be compared to a threshold (such as 0.5) to produce a binary label (0 or 1). However, the method shown can easily be extended to multiple classes. \n",
    "[feature scaling]: https://en.wikipedia.org/wiki/Feature_scaling\n",
    "[SGD]: https://en.wikipedia.org/wiki/Stochastic_gradient_descent\n",
    "[linear regression]: https://en.wikipedia.org/wiki/Linear_regression\n",
    "[logistic regression]: https://en.wikipedia.org/wiki/Logistic_regression\n",
    "[softmax]: https://en.wikipedia.org/wiki/Multinomial_logistic_regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://www.cntk.ai/jup/logistic_neuron.jpg\" width=\"300\" height=\"200\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 3\n",
    "Image(url= \"https://www.cntk.ai/jup/logistic_neuron.jpg\", width=300, height=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above figure, contributions from different input features are linearly weighted and aggregated. The resulting sum is mapped to a (0, 1) range via a [sigmoid][] function. For classifiers with more than two output labels, one can use a [softmax][] function.\n",
    "[sigmoid]: https://en.wikipedia.org/wiki/Sigmoid_function\n",
    "[softmax]: https://en.wikipedia.org/wiki/Softmax_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Import the relevant components\n",
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "import sys\n",
    "import os\n",
    "\n",
    "import cntk as C\n",
    "import cntk.tests.test_utils\n",
    "cntk.tests.test_utils.set_device_from_pytest_env() # (only needed for our build system)\n",
    "C.cntk_py.set_fixed_random_seed(1) # fix the random seed so that LR examples are repeatable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Generation\n",
    "Let us generate some synthetic data emulating the cancer example using the `numpy` library. We have two input features (represented in two-dimensions) and two output classes (benign/blue or malignant/red). \n",
    "\n",
    "In our example, each observation (a single 2-tuple of features - age and size) in the training data has a label (blue or red). Because we have two output labels, we call this a binary classification task. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define the network\n",
    "input_dim = 2\n",
    "num_output_classes = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input and Labels\n",
    "\n",
    "In this tutorial we are generating synthetic data using the `numpy` library. In real-world problems, one would use a [reader][], that would read feature values (`features`: *age* and *tumor size*) corresponding to each observation (patient). The simulated *age* variable is scaled down to have a similar range to that of the other variable. This is a key aspect of data pre-processing that we will learn more about in later tutorials. Note: in general, observations and labels can reside in higher dimensional spaces (when more features or classifications are available) and are then represented as [tensors][] in CNTK. More advanced tutorials introduce the handling of high dimensional data.\n",
    "\n",
    "[reader]: https://github.com/Microsoft/CNTK/search?p=1&q=reader&type=Wikis&utf8=%E2%9C%93\n",
    "[tensors]: https://en.wikipedia.org/wiki/Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Ensure that we always get the same results\n",
    "np.random.seed(0)\n",
    "\n",
    "# Helper function to generate a random data sample\n",
    "def generate_random_data_sample(sample_size, feature_dim, num_classes):\n",
    "    # Create synthetic data using NumPy. \n",
    "    Y = np.random.randint(size=(sample_size, 1), low=0, high=num_classes)\n",
    "\n",
    "    # Make sure that the data is separable \n",
    "    X = (np.random.randn(sample_size, feature_dim)+3) * (Y+1)\n",
    "    \n",
    "    # Specify the data type to match the input variable used later in the tutorial \n",
    "    # (default type is double)\n",
    "    X = X.astype(np.float32)    \n",
    "    \n",
    "    # convert class 0 into the vector \"1 0 0\", \n",
    "    # class 1 into the vector \"0 1 0\", ...\n",
    "    class_ind = [Y==class_number for class_number in range(num_classes)]\n",
    "    Y = np.asarray(np.hstack(class_ind), dtype=np.float32)\n",
    "    return X, Y   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create the input variables denoting the features and the label data. Note: the input \n",
    "# does not need additional info on the number of observations (Samples) since CNTK creates only \n",
    "# the network topology first \n",
    "mysamplesize = 32\n",
    "features, labels = generate_random_data_sample(mysamplesize, input_dim, num_output_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us visualize the input data.\n",
    "\n",
    "**Note**: If the import of `matplotlib.pyplot` fails, please run `conda install matplotlib`, which will fix the `pyplot` version dependencies. If you are on a python environment different from Anaconda, then use `pip install matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEPCAYAAACgFqixAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fe66aea240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the data \n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# let 0 represent malignant/red and 1 represent benign/blue \n",
    "colors = ['r' if label == 0 else 'b' for label in labels[:,0]]\n",
    "\n",
    "plt.scatter(features[:,0], features[:,1], c=colors)\n",
    "plt.xlabel(\"Age (scaled)\")\n",
    "plt.ylabel(\"Tumor size (in cm)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Creation\n",
    "\n",
    "A logistic regression (a.k.a. LR) network is a simple building block, but has powered many ML \n",
    "applications in the past decade. LR is a simple linear model that takes as input a vector of numbers describing the properties of what we are classifying (also known as a feature vector, $\\bf{x}$, the blue nodes in the figure below) and emits the *evidence* ($z$) (output of the green node, also known as \"activation\"). Each feature in the input layer is connected to an output node by a corresponding weight $w$ (indicated by the black lines of varying thickness). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://www.cntk.ai/jup/logistic_neuron2.jpg\" width=\"300\" height=\"200\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 4\n",
    "Image(url= \"https://www.cntk.ai/jup/logistic_neuron2.jpg\", width=300, height=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step is to compute the evidence for an observation. \n",
    "\n",
    "$$z = \\sum_{i=1}^n w_i \\times x_i + b = \\textbf{w} \\cdot \\textbf{x} + b$$ \n",
    "\n",
    "where $\\bf{w}$ is the weight vector of length $n$ and $b$ is known as the [bias][] term. Note: we use **bold** notation to denote vectors. \n",
    "\n",
    "The computed evidence is mapped to a (0, 1) range using a `sigmoid` (when the outcome can be in one of two possible classes) or a `softmax` function (when the outcome can be in one of more than two possible classes).\n",
    "\n",
    "Network input and output: \n",
    "- **input** variable (a key CNTK concept): \n",
    ">An **input** variable is a user-code-facing container where user-provided code fills in different observations (a data point or sample of data points, equivalent to (age, size) tuples in our example) as inputs to the model function during model learning (a.k.a.training) and model evaluation (a.k.a. testing). Thus, the shape of the `input` must match the shape of the data that will be provided.  For example, if each data point was a grayscale image of height 10 pixels and width 5 pixels, the input feature would be a vector of 50 floating-point values representing the intensity of each of the 50 pixels, and could be written as `C.input_variable(10*5, np.float32)`. Similarly, in our example the dimensions are age and tumor size, thus `input_dim` = 2. More on data and their dimensions to appear in separate tutorials. \n",
    "\n",
    "[bias]: https://www.quora.com/What-does-the-bias-term-represent-in-logistic-regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "feature = C.input_variable(input_dim, np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network setup\n",
    "\n",
    "The `linear_layer` function is a straightforward implementation of the equation above. We perform two operations:\n",
    "0. multiply the weights ($\\bf{w}$)  with the features ($\\bf{x}$) using the CNTK `times` operator,\n",
    "1. add the bias term ($b$).\n",
    "\n",
    "These CNTK operations are optimized for execution on the available hardware and the implementation hides the complexity away from the user. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a dictionary to store the model parameters\n",
    "mydict = {}\n",
    "\n",
    "def linear_layer(input_var, output_dim):\n",
    "    \n",
    "    input_dim = input_var.shape[0]\n",
    "    weight_param = C.parameter(shape=(input_dim, output_dim))\n",
    "    bias_param = C.parameter(shape=(output_dim))\n",
    "    \n",
    "    mydict['w'], mydict['b'] = weight_param, bias_param\n",
    "\n",
    "    return C.times(input_var, weight_param) + bias_param"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`z` will be used to represent the output of the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "output_dim = num_output_classes\n",
    "z = linear_layer(feature, output_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning model parameters\n",
    "\n",
    "Now that the network is set up, we would like to learn the parameters $\\bf w$ and $b$ for our simple linear layer. To do so we convert, the computed evidence ($z$) into a set of predicted probabilities ($\\textbf p$) using a `softmax` function.\n",
    "\n",
    "$$ \\textbf{p} = \\mathrm{softmax}(z)$$ \n",
    "\n",
    "The `softmax` is an activation function that normalizes the accumulated evidence into a probability distribution over the classes (Details of [`softmax`][]). Other choices of activation function can be [here][].\n",
    "\n",
    "[`softmax`]: https://www.cntk.ai/pythondocs/cntk.ops.html#cntk.ops.softmax\n",
    "\n",
    "[here]: https://docs.microsoft.com/en-us/cognitive-toolkit/Brainscript-Activation-Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "The output of the `softmax` is the probabilities of an observation belonging each of the respective classes. For training the classifier, we need to determine what behavior the model needs to mimic. In other words, we want the generated probabilities to be as close as possible to the observed labels. We can accomplish this by minimizing the difference between our output and the ground-truth labels. This difference is calculated by the *cost* or *loss* function.\n",
    "\n",
    "[`Cross-entropy`][] is a popular loss function. It is defined as:\n",
    "\n",
    "$$ H(p) = - \\sum_{j=1}^{| \\textbf y |} y_j \\log (p_j) $$  \n",
    "\n",
    "where $p$ is our predicted probability from `softmax` function and $y$ is the ground-truth label, provided with the training data. In the two-class example, the `label` variable has two dimensions (equal to the `num_output_classes` or $| \\textbf y |$). Generally speaking, the label variable will have $| \\textbf y |$ elements with 0 everywhere except at the index of the true class of the data point, where it will be 1.  Understanding the [details][] of the cross-entropy function is highly recommended.\n",
    "\n",
    "[`cross-entropy`]: http://cntk.ai/pythondocs/cntk.ops.html#cntk.ops.cross_entropy_with_softmax\n",
    "[details]: http://colah.github.io/posts/2015-09-Visual-Information/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "label = C.input_variable(num_output_classes, np.float32)\n",
    "loss = C.cross_entropy_with_softmax(z, label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluation\n",
    "\n",
    "In order to evaluate the classification, we can compute the [`classification_error`][], which is 0 if our model was correct (it assigned the true label the most probability), otherwise 1.\n",
    "[`classification_error`]: https://www.cntk.ai/pythondocs/cntk.metrics.html#cntk.metrics.classification_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "eval_error = C.classification_error(z, label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configure training\n",
    "\n",
    "The trainer strives to minimize the `loss` function using an optimization technique. In this tutorial, we will use [Stochastic Gradient Descent][] (`sgd`), one of the most popular techniques. Typically, one starts with random initialization of the model parameters (the weights and biases, in our case). For each observation, the `sgd` optimizer can calculate the `loss` or error between the predicted label and the corresponding ground-truth label, and apply [gradient descent][] to generate a new set of model parameters after each observation. \n",
    "\n",
    "The aforementioned process of updating all parameters after each observation is attractive because it does not require the entire data set (all observations) to be loaded in memory and also computes the gradient over fewer datapoints, thus allowing for training on large data sets. However, the updates generated using a single observation at a time can vary wildly between iterations. An intermediate ground is to load a small set of observations into the model and use an average of the `loss` or error from that set to update the model parameters. This subset is called a *minibatch*.\n",
    "\n",
    "With minibatches we often sample observations from the larger training dataset. We repeat the process of updating the model parameters using different combinations of training samples, and over a period of time minimize the `loss` (and the error). When the incremental error rates are no longer changing significantly, or after a preset maximum number of minibatches have been processed, we claim that our model is trained.\n",
    "\n",
    "One of the key parameters of optimization is the `learning_rate`. For now, we can think of it as a scaling factor that modulates how much we change the parameters in any iteration. We will cover more details in later tutorials. \n",
    "With this information, we are ready to create our trainer. \n",
    "\n",
    "[optimization]: https://en.wikipedia.org/wiki/Category:Convex_optimization\n",
    "[Stochastic Gradient Descent]: https://en.wikipedia.org/wiki/Stochastic_gradient_descent\n",
    "[gradient descent]: http://www.statisticsviews.com/details/feature/5722691/Getting-to-the-Bottom-of-Regression-with-Gradient-Descent.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Instantiate the trainer object to drive the model training\n",
    "learning_rate = 0.5\n",
    "lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch) \n",
    "learner = C.sgd(z.parameters, lr_schedule)\n",
    "trainer = C.Trainer(z, (loss, eval_error), [learner])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let us create some helper functions that will be needed to visualize different functions associated with training. Note: these convenience functions are for understanding what goes on under the hood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "# Define a utility function to compute the moving average.\n",
    "# A more efficient implementation is possible with np.cumsum() function\n",
    "def moving_average(a, w=10):\n",
    "    if len(a) < w: \n",
    "        return a[:]    \n",
    "    return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]\n",
    "\n",
    "\n",
    "# Define a utility that prints the training progress\n",
    "def print_training_progress(trainer, mb, frequency, verbose=1):\n",
    "    training_loss, eval_error = \"NA\", \"NA\"\n",
    "\n",
    "    if mb % frequency == 0:\n",
    "        training_loss = trainer.previous_minibatch_loss_average\n",
    "        eval_error = trainer.previous_minibatch_evaluation_average\n",
    "        if verbose: \n",
    "            print (\"Minibatch: {0}, Loss: {1:.4f}, Error: {2:.2f}\".format(mb, training_loss, eval_error))\n",
    "        \n",
    "    return mb, training_loss, eval_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the trainer\n",
    "\n",
    "We are now ready to train our Logistic Regression model. We want to decide what data we need to feed into the training engine.\n",
    "\n",
    "In this example, each iteration of the optimizer will work on 25 samples (25 dots w.r.t. the plot above) a.k.a. `minibatch_size`. We would like to train on 20000 observations. If the number of samples in the data is only 10000, the trainer will make 2 passes through the data. This is represented by `num_minibatches_to_train`. Note: in a real world scenario, we would be given a certain amount of labeled data (in the context of this example, (age, size) observations and their labels (benign / malignant)). We would use a large number of observations for training, say 70%, and set aside the remainder for the evaluation of the trained model.\n",
    "\n",
    "With these parameters we can proceed with training our simple feedforward network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Initialize the parameters for the trainer\n",
    "minibatch_size = 25\n",
    "num_samples_to_train = 20000\n",
    "num_minibatches_to_train = int(num_samples_to_train  / minibatch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minibatch: 0, Loss: 0.6931, Error: 0.32\n",
      "Minibatch: 50, Loss: 1.9350, Error: 0.36\n",
      "Minibatch: 100, Loss: 1.0764, Error: 0.32\n",
      "Minibatch: 150, Loss: 0.4856, Error: 0.20\n",
      "Minibatch: 200, Loss: 0.1319, Error: 0.08\n",
      "Minibatch: 250, Loss: 0.1330, Error: 0.08\n",
      "Minibatch: 300, Loss: 0.1012, Error: 0.04\n",
      "Minibatch: 350, Loss: 0.1091, Error: 0.04\n",
      "Minibatch: 400, Loss: 0.3094, Error: 0.08\n",
      "Minibatch: 450, Loss: 0.3230, Error: 0.12\n",
      "Minibatch: 500, Loss: 0.3986, Error: 0.20\n",
      "Minibatch: 550, Loss: 0.6744, Error: 0.24\n",
      "Minibatch: 600, Loss: 0.3004, Error: 0.12\n",
      "Minibatch: 650, Loss: 0.1676, Error: 0.12\n",
      "Minibatch: 700, Loss: 0.2777, Error: 0.12\n",
      "Minibatch: 750, Loss: 0.2311, Error: 0.04\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "# Run the trainer and perform model training\n",
    "training_progress_output_freq = 50\n",
    "plotdata = defaultdict(list)\n",
    "\n",
    "for i in range(0, num_minibatches_to_train):\n",
    "    features, labels = generate_random_data_sample(minibatch_size, input_dim, num_output_classes)\n",
    "    \n",
    "    # Assign the minibatch data to the input variables and train the model on the minibatch\n",
    "    trainer.train_minibatch({feature : features, label : labels})\n",
    "    batchsize, loss, error = print_training_progress(trainer, i, \n",
    "                                                     training_progress_output_freq, verbose=1)\n",
    "    \n",
    "    if not (loss == \"NA\" or error ==\"NA\"):\n",
    "        plotdata[\"batchsize\"].append(batchsize)\n",
    "        plotdata[\"loss\"].append(loss)\n",
    "        plotdata[\"error\"].append(error)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAACfCAYAAAAMJSWPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fe69e82d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAACfCAYAAADXno+tAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fe6b1abc18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute the moving average loss to smooth out the noise in SGD\n",
    "plotdata[\"avgloss\"] = moving_average(plotdata[\"loss\"])\n",
    "plotdata[\"avgerror\"] = moving_average(plotdata[\"error\"])\n",
    "\n",
    "# Plot the training loss and the training error\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(1)\n",
    "plt.subplot(211)\n",
    "plt.plot(plotdata[\"batchsize\"], plotdata[\"avgloss\"], 'b--')\n",
    "plt.xlabel('Minibatch number')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Minibatch run vs. Training loss')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(plotdata[\"batchsize\"], plotdata[\"avgerror\"], 'r--')\n",
    "plt.xlabel('Minibatch number')\n",
    "plt.ylabel('Label Prediction Error')\n",
    "plt.title('Minibatch run vs. Label Prediction Error')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation / Testing \n",
    "\n",
    "Now that we have trained the network, let us evaluate the trained network on data that hasn't been used for training. This is called **testing**. Let us create some new data and evaluate the average error and loss on this set. This is done using `trainer.test_minibatch`. Note the error on this previously unseen data is comparable to the training error. This is a **key** check. Should the error be larger than the training error by a large margin, it indicates that the trained model will not perform well on data that it has not seen during training. This is known as [overfitting][]. There are several ways to address overfitting that are beyond the scope of this tutorial, but the Cognitive Toolkit provides the necessary components to address overfitting.\n",
    "\n",
    "Note: we are testing on a single minibatch for illustrative purposes. In practice, one runs several minibatches of test data and reports the average. \n",
    "\n",
    "**Question** Why is this suggested? Try plotting the test error over several set of generated data sample and plot using plotting functions used for training. Do you see a pattern?\n",
    "\n",
    "[overfitting]: https://en.wikipedia.org/wiki/Overfitting\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the trained model on a newly generated dataset\n",
    "test_minibatch_size = 25\n",
    "features, labels = generate_random_data_sample(test_minibatch_size, input_dim, num_output_classes)\n",
    "\n",
    "trainer.test_minibatch({feature : features, label : labels}) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking prediction / evaluation \n",
    "For evaluation, we softmax the output of the network into a probability distribution over the two classes, the probability of each observation being malignant or benign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "out = C.softmax(z)\n",
    "result = out.eval({feature : features})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us compare the ground-truth label with the predictions. They should be in agreement.\n",
    "\n",
    "**Question:** \n",
    "- How many predictions were mislabeled? Can you change the code below to identify which observations were misclassified? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label    : [1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1]\n",
      "Predicted: [0, 0]\n"
     ]
    }
   ],
   "source": [
    "print(\"Label    :\", [np.argmax(label) for label in labels])\n",
    "print(\"Predicted:\", [np.argmax(x) for x in result[0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization\n",
    "It is desirable to visualize the results. In this example, the data can be conveniently plotted using two spatial dimensions for the input (patient age on the x-axis and tumor size on the y-axis), and a color dimension for the output (red for malignant and blue for benign). For data with higher dimensions, visualization can be challenging. There are advanced dimensionality reduction techniques, such as [t-sne][] that allow for such visualizations.\n",
    "\n",
    "[t-sne]: https://en.wikipedia.org/wiki/T-distributed_stochastic_neighbor_embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8.00007153 -8.00006485]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEPCAYAAACtCNj2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nICIiUUoKIiIS9f8Bm5K9Ti0pqcIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fe76a3cba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Model parameters\n",
    "print(mydict['b'].value)\n",
    "\n",
    "bias_vector   = mydict['b'].value\n",
    "weight_matrix = mydict['w'].value\n",
    "\n",
    "# Plot the data \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# let 0 represent malignant/red, and 1 represent benign/blue\n",
    "colors = ['r' if label == 0 else 'b' for label in labels[:,0]]\n",
    "plt.scatter(features[:,0], features[:,1], c=colors)\n",
    "plt.plot([0, bias_vector[0]/weight_matrix[0][1]], \n",
    "         [ bias_vector[1]/weight_matrix[0][0], 0], c = 'g', lw = 3)\n",
    "plt.xlabel(\"Patient age (scaled)\")\n",
    "plt.ylabel(\"Tumor size (in cm)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Exploration Suggestions** \n",
    "- Try exploring how the classifier behaves with different data distributions - e.g., changing the `minibatch_size` parameter from 25 to 64. Why is the error increasing?\n",
    "- Try exploring different activation functions\n",
    "- Try exploring different learners \n",
    "- You can explore training a [multiclass logistic regression][] classifier.\n",
    "\n",
    "[multiclass logistic regression]: https://en.wikipedia.org/wiki/Multinomial_logistic_regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}