Sklearn_with_Docker.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sklearn and Docker! And some Flask\n",
    "A match made in heaven\n",
    "\n",
    "__NOTE__: The docker image (as a .tar) won't be included as it is over 1GB in size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "__author__ = 'Alistair Rogers'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training and Persistence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the stereotypical iris example..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import flask\n",
    "import pandas as pd\n",
    "from sklearn import datasets\n",
    "from sklearn import svm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "svm = svm.SVC()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X, y = iris.data, iris.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X = pd.DataFrame(X)\n",
    "X.columns = ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = pd.DataFrame(y)\n",
    "y.columns = ['Species']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Sepal_Length  Sepal_Width  Petal_Length  Petal_Width\n",
      "0           5.1          3.5           1.4          0.2\n",
      "1           4.9          3.0           1.4          0.2\n",
      "2           4.7          3.2           1.3          0.2\n",
      "3           4.6          3.1           1.5          0.2\n",
      "4           5.0          3.6           1.4          0.2\n"
     ]
    }
   ],
   "source": [
    "print(X.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/arogers2/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Serialise the model for scoring later on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "pickle.dump(svm, open('svm_iris.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's make a flask app for scoring on new data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the following as <b>app.py</b>\n",
    "\n",
    "You can also create an empty __init.py__ if you'd like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from flask import Flask\n",
      "from flask import request\n",
      "from flask import jsonify\n",
      "from sklearn import svm\n",
      "import pickle\n",
      "import numpy as np\n",
      "import pandas as pd\n",
      "\n",
      "app = Flask(__name__)\n",
      "\n",
      "# Create a test method\n",
      "@app.route('/isalive')\n",
      "def index():\n",
      "\treturn \"This API is Alive\"\n",
      "\n",
      "@app.route('/prediction', methods=['POST', 'GET'])\n",
      "def get_prediction():\n",
      "\n",
      " # GET the JSONified Pandas dataframe\n",
      " print('Requesting...')\n",
      " json = request.args.get('data')\n",
      "\n",
      " # Transform JSON into Pandas DataFrame\n",
      " print('dataframing...')\n",
      " df = pd.read_json(json)\n",
      " df = df.reset_index(drop=True)\n",
      "\n",
      " # Read the serialised model\n",
      " print('reading model')\n",
      " modelname = 'svm_iris.pkl'\n",
      " print('Loading %s' % modelname)\n",
      " loaded_model = pickle.load(open(modelname, 'rb'), encoding='latin1')\n",
      "\n",
      " # Get predictions\n",
      " print('predicting')\n",
      " prediction = loaded_model.predict(df)\n",
      " prediction_df = pd.DataFrame(prediction)\n",
      " prediction_df.columns = ['Species']\n",
      " prediction_df.reset_index(drop=True)\n",
      "\n",
      " # OPTIONAL: Concatenate Predictions with original Dataframe\n",
      " df_with_preds = pd.concat([df, prediction_df], axis=1)\n",
      " return df_with_preds.to_json()\n",
      "\n",
      "if __name__ == '__main__':\n",
      " app.run(port=5000,host='0.0.0.0')\n",
      " #app.run(debug=True)\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cat app.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check if the app works\n",
    "Open a terminal window and navigate to the directory that you are working from. Then run __python docker/app.py__\n",
    "\n",
    "You should get something like this (while debug mode is on..):\n",
    " * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)\n",
    "\n",
    "We will also create a json to test the api endpoint. We will create this with the first 10 rows of the data that was used to train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"Sepal_Length\":{\"1\":4.9,\"2\":4.7,\"3\":4.6,\"4\":5.0,\"5\":5.4,\"6\":4.6,\"7\":5.0,\"8\":4.4,\"9\":4.9},\"Sepal_Width\":{\"1\":3.0,\"2\":3.2,\"3\":3.1,\"4\":3.6,\"5\":3.9,\"6\":3.4,\"7\":3.4,\"8\":2.9,\"9\":3.1},\"Petal_Length\":{\"1\":1.4,\"2\":1.3,\"3\":1.5,\"4\":1.4,\"5\":1.7,\"6\":1.4,\"7\":1.5,\"8\":1.4,\"9\":1.5},\"Petal_Width\":{\"1\":0.2,\"2\":0.2,\"3\":0.2,\"4\":0.2,\"5\":0.4,\"6\":0.3,\"7\":0.2,\"8\":0.2,\"9\":0.1}}'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.iloc[1:10, :].to_json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try the testing isalive method first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "local_test = requests.get('http://0.0.0.0:5000/isalive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'This API is Alive'\n"
     ]
    }
   ],
   "source": [
    "print(local_test.content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see what happens when we feed some data in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = X.iloc[1:10, :].to_json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "local_prediction = requests.get('http://0.0.0.0:5000/prediction?data='+data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"Petal_Length\":{\"0\":1.4,\"1\":1.3,\"2\":1.5,\"3\":1.4,\"4\":1.7,\"5\":1.4,\"6\":1.5,\"7\":1.4,\"8\":1.5},\"Petal_Width\":{\"0\":0.2,\"1\":0.2,\"2\":0.2,\"3\":0.2,\"4\":0.4,\"5\":0.3,\"6\":0.2,\"7\":0.2,\"8\":0.1},\"Sepal_Length\":{\"0\":4.9,\"1\":4.7,\"2\":4.6,\"3\":5.0,\"4\":5.4,\"5\":4.6,\"6\":5.0,\"7\":4.4,\"8\":4.9},\"Sepal_Width\":{\"0\":3.0,\"1\":3.2,\"2\":3.1,\"3\":3.6,\"4\":3.9,\"5\":3.4,\"6\":3.4,\"7\":2.9,\"8\":3.1},\"Species\":{\"0\":2,\"1\":2,\"2\":2,\"3\":2,\"4\":2,\"5\":2,\"6\":2,\"7\":2,\"8\":2}}'"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "local_prediction.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In your terminal, you should see something like this:\n",
    "\n",
    "Requesting... <br>\n",
    "dataframing... <br>\n",
    "reading model <br>\n",
    "Loading svm_iris.pkl <br>\n",
    "predicting <br>\n",
    "127.0.0.1 - - [05/Jun/2018 09:28:32] \"GET /prediction?data=%7B%22Sepal_Length%22:%7B%221%22:4.9,%222%22:4.7,%223%22:4.6,%224%22:<br>5.0,%225%22:5.4,%226%22:4.6,%227%22:5.0,%228%22:4.4,%229%22:4.9%7D,%22<br>Sepal_Width%22:%7B%221%22:3.0,%222%22:3.2,%223%22:3.1,%224%22:3.6,%225<br>%22:3.9,%226%22:3.4,%227%22:3.4,%228%22:2.9,%229%22:3.1%7D,%22Petal_Le<br>ngth%22:%7B%221%22:1.4,%222%22:1.3,%223%22:1.5,%224%22:1.4,%225%22:1.7<br>,%226%22:1.4,%227%22:1.5,%228%22:1.4,%229%22:1.5%7D,%22Petal_Width%22:<br>%7B%221%22:0.2,%222%22:0.2,%223%22:0.2,%224%22:0.2,%225%22:0.4,%226%22<br>:0.3,%227%22:0.2,%228%22:0.2,%229%22:0.1%7D%7D HTTP/1.1\" 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Petal_Length  Petal_Width  Sepal_Length  Sepal_Width  Species\n",
      "0           1.4          0.2           4.9          3.0        2\n",
      "1           1.3          0.2           4.7          3.2        2\n",
      "2           1.5          0.2           4.6          3.1        2\n",
      "3           1.4          0.2           5.0          3.6        2\n",
      "4           1.7          0.4           5.4          3.9        2\n",
      "5           1.4          0.3           4.6          3.4        2\n",
      "6           1.5          0.2           5.0          3.4        2\n",
      "7           1.4          0.2           4.4          2.9        2\n",
      "8           1.5          0.1           4.9          3.1        2\n"
     ]
    }
   ],
   "source": [
    "print(pd.read_json(local_prediction.text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well that all works, fantastic! Close your connection with a CTRL + C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building the Docker Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two things you need to build a Docker image (besides Docker installed on your machine).\n",
    "\n",
    "A Dockerfile\n",
    "- Specifies the commands to run and sources dependencies.\n",
    "<br>\n",
    "\n",
    "A requirements file\n",
    "- A list of all the dependencies you require, in this case it will be the python packages used"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Dockerfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FROM python:3.5.3\n",
      "MAINTAINER Alistair Rogers\n",
      "\n",
      "# Create a directory to work from\n",
      "WORKDIR /app/\n",
      "\n",
      "# Place the requirements file specifying all of the dependencies in that file\n",
      "COPY requirements.txt /app/\n",
      "RUN pip install -r ./requirements.txt\n",
      "\n",
      "# Place the Flask application and pickled model file into the directory\n",
      "COPY app.py __init__.py /app/\n",
      "COPY svm_iris.pkl /app/\n",
      "\n",
      "# Expose the app on port 5000\n",
      "EXPOSE 5000\n",
      "\n",
      "ENTRYPOINT python ./app.py\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cat Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Requirements File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy==1.13\n",
      "scipy==0.19.1\n",
      "Flask==0.12.2\n",
      "scikit_learn==0.18.1\n",
      "pandas==0.18.1\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cat requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Build the Docker Image!!\n",
    "\n",
    "You can do this with the following command: <br>\n",
    "<b>docker build . -t [NAME]</b>\n",
    "\n",
    "We will call this image __iris_svm__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending build context to Docker daemon  1.193GB\n",
      "Step 1/9 : FROM python:3.5.3\n",
      " ---> 56b15234ac1d\n",
      "Step 2/9 : MAINTAINER Alistair Rogers\n",
      " ---> Using cache\n",
      " ---> e8948cd02846\n",
      "Step 3/9 : WORKDIR /app/\n",
      " ---> Using cache\n",
      " ---> 2aa2e410bb64\n",
      "Step 4/9 : COPY requirements.txt /app/\n",
      " ---> Using cache\n",
      " ---> c1b090adbb9d\n",
      "Step 5/9 : RUN pip install -r ./requirements.txt\n",
      " ---> Using cache\n",
      " ---> cee84e2a220b\n",
      "Step 6/9 : COPY app.py __init__.py /app/\n",
      " ---> Using cache\n",
      " ---> 159569d5d750\n",
      "Step 7/9 : COPY svm_iris.pkl /app/\n",
      " ---> Using cache\n",
      " ---> 89dc1650ecee\n",
      "Step 8/9 : EXPOSE 5000\n",
      " ---> Using cache\n",
      " ---> 4475acdeb6ab\n",
      "Step 9/9 : ENTRYPOINT python ./app.py\n",
      " ---> Using cache\n",
      " ---> a644e6b2467e\n",
      "Successfully built a644e6b2467e\n",
      "Successfully tagged iris_svm:latest\n"
     ]
    }
   ],
   "source": [
    "!docker build . -t iris_svm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can save this docker image as a .tar file and do some other stuff with it. We could send it to someone else who has docker so they can run it or use a cloud service to expose the model as a service etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "!docker save iris_svm > iris_svm.tar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the tar file is ready and available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dockerfile                __init__.py               requirements.txt\r\n",
      "README.md                 app.py                    svm_iris.pkl\r\n",
      "Sklearn_with_Docker.ipynb iris_svm.tar\r\n"
     ]
    }
   ],
   "source": [
    "!ls "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the Docker Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to run a docker image from a tar file, we must first load it:\n",
    "    <b>docker load -i NAME.tar</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded image: iris_svm:latest\r\n"
     ]
    }
   ],
   "source": [
    "!docker load -i iris_svm.tar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to run the app on port 5000 (as specified in the flask app) then message we get when we run it will say it's listening on port 5000, but if we try to access that on the same host we get an error.\n",
    "\n",
    "So need to expose the port outside the container that it's running in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run it on ports 5001:5000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this on your command line! \n",
    "<b>docker run -p 5001:5000 -it iris_svm</b>\n",
    "We can't run it here because it would continuously run and no other cell could be executed in this notebook\n",
    "\n",
    "You should get a similar output as before:\n",
    "\n",
    "Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This API is Alive'"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "request_docker_test = requests.get('http://localhost:5001/isalive')\n",
    "request_docker_test.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets try this with the same data as before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"Petal_Length\":{\"0\":1.4,\"1\":1.3,\"2\":1.5,\"3\":1.4,\"4\":1.7,\"5\":1.4,\"6\":1.5,\"7\":1.4,\"8\":1.5},\"Petal_Width\":{\"0\":0.2,\"1\":0.2,\"2\":0.2,\"3\":0.2,\"4\":0.4,\"5\":0.3,\"6\":0.2,\"7\":0.2,\"8\":0.1},\"Sepal_Length\":{\"0\":4.9,\"1\":4.7,\"2\":4.6,\"3\":5.0,\"4\":5.4,\"5\":4.6,\"6\":5.0,\"7\":4.4,\"8\":4.9},\"Sepal_Width\":{\"0\":3.0,\"1\":3.2,\"2\":3.1,\"3\":3.6,\"4\":3.9,\"5\":3.4,\"6\":3.4,\"7\":2.9,\"8\":3.1},\"Species\":{\"0\":2,\"1\":2,\"2\":2,\"3\":2,\"4\":2,\"5\":2,\"6\":2,\"7\":2,\"8\":2}}'"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "request_docker_pred = requests.get('http://localhost:5001/prediction?data='+data)\n",
    "request_docker_pred.text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Petal_Length  Petal_Width  Sepal_Length  Sepal_Width  Species\n",
      "0           1.4          0.2           4.9          3.0        2\n",
      "1           1.3          0.2           4.7          3.2        2\n",
      "2           1.5          0.2           4.6          3.1        2\n",
      "3           1.4          0.2           5.0          3.6        2\n",
      "4           1.7          0.4           5.4          3.9        2\n",
      "5           1.4          0.3           4.6          3.4        2\n",
      "6           1.5          0.2           5.0          3.4        2\n",
      "7           1.4          0.2           4.4          2.9        2\n",
      "8           1.5          0.1           4.9          3.1        2\n"
     ]
    }
   ],
   "source": [
    "print(pd.read_json(request_docker_pred.text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Woohoo! \n",
    "\n",
    "Now CTRL + C to stop your docker"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}