simple-nn-in-zoo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**First of all, set environment variables and initialize spark context:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Trying to search from: /tools/analytics-zoo-dist/lib/analytics-zoo-bigdl_0.8.0-spark_2.3.1-0.6.0-SNAPSHOT-python-api.zip/zoo, but can not find the jar for Analytics-Zoo\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using /tools/spark-2.3.1-bin-hadoop2.7\n",
      "Prepending /tools/spark-2.3.1-bin-hadoop2.7/python/lib/py4j-0.10.7-src.zip to sys.path\n",
      "Prepending /tools/spark-2.3.1-bin-hadoop2.7/python/lib/pyspark.zip to sys.path\n"
     ]
    }
   ],
   "source": [
    "from zoo.common.nncontext import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pyspark.conf.SparkConf at 0x7f5e0cb11f90>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create spark conf, you can set memory, cores, or other configuration\n",
    "conf = init_spark_conf()\n",
    "conf.set(\"spark.executor.memory\", \"5g\")\n",
    "conf.set(\"spark.driver.memory\", \"5g\")\n",
    "conf.set(\"spark.executor.cores\", \"1\")\n",
    "conf.set(\"spark.driver.cores\", \"1\")\n",
    "conf.set(\"spark.cores.max\", \"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pyspark.conf.SparkConf at 0x7f5e0cb11f90>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bigdl_jar = os.environ[\"BIGDL_JARS\"]\n",
    "conf.set(\"spark.executor.extraClassPath\", bigdl_jar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "zoo_pyzip = os.environ[\"ZOO_PYZIP\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Option 1: Set master for local mode and create spark context\n",
    "# conf.setMaster(\"local[*]\")\n",
    "# sc = init_nncontext(conf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Option 2: Create spark context to connect spark master. i.e. spark-master-1\n",
    "conf.setMaster(\"spark-master-1\")\n",
    "sc = init_nncontext(conf)\n",
    "sc.addPyFile(zoo_pyzip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# A simple neural network  example with Analytics Zoo\n",
    "\n",
    "----\n",
    "\n",
    "We will now take a look at a first concrete example of a neural network, which makes use of Keras (v1.2.2) API in [Analytics Zoo](https://github.com/intel-analytics/analytics-zoo) to learn to classify hand-written digits. Unless you already have experience with Keras or similar libraries, you will not understand everything about this first example right away. You probably haven't even installed Analytics zoo yet. Don't worry, that is perfectly fine. In the next chapter, we will review each element in our example and explain them in detail. So don't worry if some steps seem arbitrary or look like magic to you! We've got to start somewhere.\n",
    "\n",
    "The problem we are trying to solve here is to classify grayscale images of handwritten digits (28 pixels by 28 pixels), into their 10 categories (0 to 9). The dataset we will use is the MNIST dataset, a classic dataset in the machine learning community, which has been around for almost as long as the field itself and has been very intensively studied. It's a set of 60,000 training images, plus 10,000 test images, assembled by the National Institute of Standards and Technology (the NIST in MNIST) in the 1980s. You can think of \"solving\" MNIST as the \"Hello World\" of deep learning -- it's what you do to verify that your algorithms are working as expected. As you become a machine learning practitioner, you will see MNIST come up over and over again, in scientific papers, blog posts, and so on.\n",
    "\n",
    "The MNIST dataset  comes pre-loaded in the Keras API of Analytics Zoo, in the form of a set of four Numpy arrays:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Datasets import\n",
    "_In Keras one could use following code to import the datasets:_\n",
    "\n",
    "    from keras.datasets import mnist\n",
    "_Just replace it with following in Analytics zoo:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Extracting', '/tmp/.zoo/dataset/mnist/train-images-idx3-ubyte.gz')\n",
      "('Extracting', '/tmp/.zoo/dataset/mnist/train-labels-idx1-ubyte.gz')\n",
      "('Extracting', '/tmp/.zoo/dataset/mnist/t10k-images-idx3-ubyte.gz')\n",
      "('Extracting', '/tmp/.zoo/dataset/mnist/t10k-labels-idx1-ubyte.gz')\n"
     ]
    }
   ],
   "source": [
    "from zoo.pipeline.api.keras.datasets import mnist\n",
    "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "`train_images` and `train_labels` form the \"training set\", the data that the model will learn from. The model will then be tested on the \n",
    "\"test set\", `test_images` and `test_labels`. Our images are encoded as Numpy arrays, and the labels are simply an array of digits, ranging \n",
    "from 0 to 9. There is a one-to-one correspondence between the images and the labels.\n",
    "\n",
    "Let's have a look at the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28, 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60000"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 28, 28, 1)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Our workflow will be as follow: first we will present our neural network with the training data, `train_images` and `train_labels`. The \n",
    "network will then learn to associate images and labels. Finally, we will ask the network to produce predictions for `test_images`, and we \n",
    "will verify if these predictions match the labels from `test_labels`.\n",
    "\n",
    "Let's build our network -- again, remember that you aren't supposed to understand everything about this example just yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Module import\n",
    "_In Keras one could use following code to import the modules we need to build the network:_\n",
    "\n",
    "    from keras import models\n",
    "    from keras import layers\n",
    "_Just replace it with following in Analytics zoo:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from zoo.pipeline.api.keras import models\n",
    "from zoo.pipeline.api.keras import layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating: createZooKerasSequential\n",
      "creating: createZooKerasDense\n",
      "creating: createZooKerasDense\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<zoo.pipeline.api.keras.models.Sequential at 0x7f5e01165250>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "network = models.Sequential()\n",
    "network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))\n",
    "network.add(layers.Dense(10, activation='softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The core building block of neural networks is the \"layer\", a data-processing module which you can conceive as a \"filter\" for data. Some \n",
    "data comes in, and comes out in a more useful form. Precisely, layers extract _representations_ out of the data fed into them -- hopefully \n",
    "representations that are more meaningful for the problem at hand. Most of deep learning really consists of chaining together simple layers \n",
    "which will implement a form of progressive \"data distillation\". A deep learning model is like a sieve for data processing, made of a \n",
    "succession of increasingly refined data filters -- the \"layers\".\n",
    "\n",
    "Here our network consists of a sequence of two `Dense` layers, which are densely-connected (also called \"fully-connected\") neural layers. \n",
    "The second (and last) layer is a 10-way \"softmax\" layer, which means it will return an array of 10 probability scores (summing to 1). Each \n",
    "score will be the probability that the current digit image belongs to one of our 10 digit classes.\n",
    "\n",
    "To make our network ready for training, we need to pick three more things, as part of \"compilation\" step:\n",
    "\n",
    "* A loss function: the is how the network will be able to measure how good a job it is doing on its training data, and thus how it will be \n",
    "able to steer itself in the right direction.\n",
    "* An optimizer: this is the mechanism through which the network will update itself based on the data it sees and its loss function.\n",
    "* Metrics to monitor during training and testing. Here we will only care about accuracy (the fraction of the images that were correctly \n",
    "classified).\n",
    "\n",
    "The exact purpose of the loss function and the optimizer will be made clear throughout the next two chapters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating: createRMSprop\n",
      "creating: createZooKerasSparseCategoricalCrossEntropy\n",
      "creating: createZooKerasSparseCategoricalAccuracy\n"
     ]
    }
   ],
   "source": [
    "network.compile(optimizer='rmsprop',\n",
    "                loss='sparse_categorical_crossentropy',\n",
    "                metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Before training, we will preprocess our data by reshaping it into the shape that the network expects, and scaling it so that all values are in \n",
    "the `[0, 1]` interval. Previously, our training images for instance were stored in an array of shape `(60000, 28, 28)` of type `uint8` with \n",
    "values in the `[0, 255]` interval. We transform it into a `float32` array of shape `(60000, 28 * 28)` with values between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "train_images = train_images.reshape((60000, 28 * 28))\n",
    "train_images = train_images.astype('float32') / 255\n",
    "\n",
    "test_images = test_images.reshape((10000, 28 * 28))\n",
    "test_images = test_images.astype('float32') / 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Train model\n",
    "\n",
    "We are now ready to train our network, which in Keras API of Analytics Zoo is done via a call to the `fit` method of the network: \n",
    "we \"fit\" the model to its training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "network.fit(train_images, train_labels, nb_epoch=5, batch_size=128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Messages below is the last INFO of training, you can find full training process in INFO, which outputs in your terminal or IDE (not the output of the program)\n",
    "\n",
    "_INFO - Trained 128 records in 0.018066358 seconds. Throughput is 7084.992 records/second. Loss is 0.012087556._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We quickly reach an accuracy of 0.989 (i.e. 98.9%) on the training data. Now let's check that our model performs well on the test set too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('test_acc:', 0.9778000116348267)\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = network.evaluate(test_images, test_labels, batch_size=32)\n",
    "print('test_acc:', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This concludes our very first example -- you just saw how we could build and a train a neural network to classify handwritten digits, in \n",
    "less than 20 lines of Python code. In the next chapter, we will go in detail over every moving piece we just previewed, and clarify what is really \n",
    "going on behind the scenes. You will learn about \"tensors\", the data-storing objects going into the network, about tensor operations, which \n",
    "layers are made of, and about gradient descent, which allows our network to learn from its training examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Save model\n",
    "\n",
    "After training, save pre-trained model to local/remote path(hdfs, s3,etc.) for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "network.saveModel(\"/tmp/zoo.model\", weightPath=None, over_write=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Load Model\n",
    "\n",
    "Load pre-trained model for inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from zoo.pipeline.api.net import *\n",
    "model = Net.load(\"/tmp/zoo.model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Prediction\n",
    "\n",
    "Use loaded model to predict on test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def map_predict_label(l):\n",
    "    return np.array(l).argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "Ground Truth labels:\n",
      "7, 2, 1, 0, 4, 1, 4, 9\n",
      "Predicted labels:\n",
      "7, 2, 1, 0, 4, 1, 4, 9\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAABMCAYAAAB9PUwnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "# matplotlib.use('Agg')\n",
    "%pylab inline\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imshow\n",
    "import numpy as np\n",
    "\n",
    "predictions = model.predict(test_images)\n",
    "imshow(np.column_stack([s.reshape((28,28)) for s in test_images[:8]]),cmap='gray'); plt.axis('off')\n",
    "print 'Ground Truth labels:'\n",
    "print ', '.join(str(s) for s in test_labels[:8])\n",
    "print 'Predicted labels:'\n",
    "print ', '.join(str(map_predict_label(s)) for s in predictions.take(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}