Use%2BLagrangian%2Brelaxation%2BLocal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Solve a Generalized Assignment Problem using Lagrangian relaxation\n",
    "\n",
    "This tutorial includes data and information that you need to set up Decision Optimization engines and build mathematical programming models to solve a Generalized Assignment Problem using Lagrangian relaxation.\n",
    "\n",
    "\n",
    "When you finish this tutorial, you'll have a foundational knowledge of _Prescriptive Analytics_.\n",
    "\n",
    ">This notebook is part of the [Prescriptive Analytics for Python](https://rawgit.com/IBMDecisionOptimization/docplex-doc/master/docs/index.html)\n",
    "\n",
    ">You will need a valid subscription to Decision Optimization on Cloud ([here](https://developer.ibm.com/docloud)) or a local installation of CPLEX Optimizers. \n",
    "\n",
    "Some familiarity with Python is recommended. This notebook runs on Python 2.7 and 3.5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "## Table of contents\n",
    "* [Describe the business problem](#describe-problem)\n",
    "* [How Decision Optimization can help](#do-help) \n",
    "* [Use Decision Optimization to create and solve the model](#do-model-create-solve)\n",
    "   1. [Download the library](#Download-the-library)<br>\n",
    "   2. [Set up the prescriptive engine](#Set-up-the-prescriptive-engine)<br>\n",
    "   3. [Model the Data](#Step-3:-Model-the-data)<br>\n",
    "   4. [Set up the prescriptive model](#Set-up-the-prescriptive-model)<br>\n",
    "      4.1 [Create the DOcplex model](#create-model)<br>\n",
    "      4.2 [Define the decision variables](#Define-the-decision-variables)<br>\n",
    "      4.3 [Define the business constraints](#Express-the-business-constraints)<br>\n",
    "      4.4 [Solve the model by using the Decision Optimization solve service](#solve-model-solve-service)<br>\n",
    "      4.5 [Solve the model by using the Lagrangian Relaxation method](#solve-model-lagrangian-relaxation)<br>\n",
    "   5. [Investigate the solution and run an example analysis](#Investigate-the-solution)<br>\n",
    "* [Summary](#summary)<br>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a id=\"describe-problem\"></a>\n",
    "## Describe the business problem   \n",
    "\n",
    "\n",
    "This notebook illustrates how to solve an optimization model using Lagrangian relaxation technics. \n",
    "It solves a generalized assignment problem (GAP), as defined by Wolsey, using this relaxation technic.\n",
    "\n",
    "The main aim is to show multiple optimizations through modifications of different models that exist in a single environment; not to show how to solve a GAP problem.\n",
    "\n",
    "In the field of Mathematical Programming, this technic is based on an approximation of a difficult, constrained problem to a simpler problem: you remove difficult constraints by integrating them in the objective function, penalizing the objective if a constraint is not respected.\n",
    "\n",
    "This method penalizes violations of inequality constraints by using a Lagrange multiplier that imposes a cost on violations. The added costs are used instead of the strict inequality constraints in the optimization. \n",
    "\n",
    "In practice, the relaxed problem can often be solved more easily than the original problem.\n",
    "\n",
    "For more information, see the following Wikipedia articles: [Generalized assignment problem](https://en.wikipedia.org/wiki/Generalized_assignment_problem) and [Lagrangian relaxation](https://en.wikipedia.org/wiki/Lagrangian_relaxation).\n",
    "\n",
    "This notebook first solves the standard problem, which is not important here, then shows how to reformulate the problem to meet the Lagrangian Relaxation features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"do-help\"></a>\n",
    "## How  decision optimization can help\n",
    "\n",
    "Prescriptive analytics (decision optimization) technology recommends actions that are based on desired outcomes. It considers specific scenarios, resources, and knowledge of past and current events. With this insight, your organization can make better decisions and have greater control over business outcomes.\n",
    "\n",
    "Prescriptive analytics is the next step on the path to insight-based actions. It creates value through synergy with predictive analytics, which analyzes data to predict future outcomes. Prescriptive analytics takes that insight to the next level by suggesting the optimal way to handle a future situation. Organizations that act fast in dynamic conditions and make superior decisions in uncertain environments gain a strong competitive advantage.\n",
    "\n",
    "With prescriptive analytics, you can:\n",
    "\n",
    "* Automate the complex decisions and trade-offs to better manage your limited resources.\n",
    "    \n",
    "* Take advantage of a future opportunity or mitigate a future risk.\n",
    "    \n",
    "* Proactively update recommendations based on changing events.\n",
    "    \n",
    "* Meet operational goals, increase customer loyalty, prevent threats and fraud, and optimize business processes.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"do-model-create-solve\"></a>\n",
    "## Use Decision Optimization to create and solve the model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a id=\"Download-the-library\"></a>\n",
    "### 1. Download the library\n",
    "\n",
    "Run the following code to install the Decision Optimization CPLEX Modeling library.  The *DOcplex* library contains two modeling packages, mathematical programming (docplex.mp) package and constraint programming (docplex.cp) package.\n",
    "\n",
    "In the following code, `real.prefix` is used to ensure that the script is not running inside a virtual environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "try:\n",
    "    import docplex.mp\n",
    "except:\n",
    "    if hasattr(sys, 'real_prefix'):\n",
    "        !pip install docplex \n",
    "    else:\n",
    "        !pip install --user docplex      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"Set-up-the-prescriptive-engine\"></a>\n",
    "### 2. Set up the prescriptive engine\n",
    "\n",
    "To solve DOcplex models, you need access to the DOcplexcloud solve service.\n",
    "\n",
    "* Subscribe to the [Decision Optimization on Cloud](https://developer.ibm.com/docloud) (DOcplexcloud) service.\n",
    "* Get the service base URL and personal API key.\n",
    "* Enter the URL and API key in the cell below, enclosed in quotation marks (\"\"), and run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "render": false
   },
   "outputs": [],
   "source": [
    "url = None\n",
    "key = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"Step-3:-Model-the-data\"></a>\n",
    "### 3. Model the data\n",
    "In this scenario, the data is simple. It is delivered as 3 input arrays: A, B, and C. The data does not need changing or refactoring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "B = [15, 15, 15]\n",
    "C = [\n",
    "    [ 6, 10, 1],\n",
    "    [12, 12, 5],\n",
    "    [15,  4, 3],\n",
    "    [10,  3, 9],\n",
    "    [8,   9, 5]\n",
    "]\n",
    "A = [\n",
    "    [ 5,  7,  2],\n",
    "    [14,  8,  7],\n",
    "    [10,  6, 12],\n",
    "    [ 8,  4, 15],\n",
    "    [ 6, 12,  5]\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"Set-up-the-prescriptive-model\"></a>\n",
    "### 4. Set up the prescriptive model\n",
    "\n",
    "Start with viewing the environment information. This information should be updated when you run the notebook.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* system is: Linux 64bit\n",
      "* Python is present, version is 3.5.2\n",
      "* docplex is present, version is (2, 0, 15)\n",
      "* CPLEX wrapper is present, version is 12.7.0.0, located at: /opt/conda/lib/python3.5/site-packages\n"
     ]
    }
   ],
   "source": [
    "from docplex.mp.environment import Environment\n",
    "env = Environment()\n",
    "env.print_information()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We will first create an optimization problem that is composed of 2 basic constraint blocks. Then, we will resolve the problem using Lagrangian Relaxation on 1 of the constraint blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a id=\"create-model\"></a>\n",
    "#### 4.1 Create the DOcplex model\n",
    "The model contains the business constraints and the objective.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from docplex.mp.model import Model\n",
    "\n",
    "mdl = Model(\"GAP\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a id=\"Define-the-decision-variables\"></a>\n",
    "#### 4.2 Define the decision variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#As=5, #Bs=3, #Cs=5\n"
     ]
    }
   ],
   "source": [
    "print(\"#As={}, #Bs={}, #Cs={}\".format(len(A), len(B), len(C)))\n",
    "number_of_cs = len(C)\n",
    "# variables\n",
    "x_vars = [mdl.binary_var_list(c, name=None) for c in C]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"Express-the-business-constraints\"></a>\n",
    "#### 4.3 Define the business constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: GAP\n",
      " - number of variables: 15\n",
      "   - binary=15, integer=0, continuous=0\n",
      " - number of constraints: 8\n",
      "   - linear=8\n",
      " - parameters: defaults\n"
     ]
    }
   ],
   "source": [
    "# constraints\n",
    "cts = mdl.add_constraints(mdl.sum(xv) <= 1 for xv in x_vars)\n",
    "\n",
    "mdl.add_constraints(mdl.sum(x_vars[ii][j] * A[ii][j] for ii in range(number_of_cs)) <= bs for j, bs in enumerate(B))\n",
    "\n",
    "# objective\n",
    "total_profit = mdl.sum(mdl.scal_prod(x_i, c_i) for c_i, x_i in zip(C, x_vars))\n",
    "mdl.maximize(total_profit)\n",
    "mdl.print_information()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"solve-model-solve-service\"></a>\n",
    "#### 4.4. Solve the model by using the Decision Optimization solve service\n",
    "\n",
    "Use the Decision Optimization on Cloud solve service to solve the model or use a local engine to solve the model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found incumbent of value 0.000000 after 0.00 sec. (0.00 ticks)\n",
      "Tried aggregator 1 time.\n",
      "MIP Presolve modified 7 coefficients.\n",
      "Reduced MIP has 8 rows, 15 columns, and 30 nonzeros.\n",
      "Reduced MIP has 15 binaries, 0 generals, 0 SOSs, and 0 indicators.\n",
      "Presolve time = 0.00 sec. (0.03 ticks)\n",
      "Probing time = 0.00 sec. (0.01 ticks)\n",
      "Tried aggregator 1 time.\n",
      "Reduced MIP has 8 rows, 15 columns, and 30 nonzeros.\n",
      "Reduced MIP has 15 binaries, 0 generals, 0 SOSs, and 0 indicators.\n",
      "Presolve time = 0.00 sec. (0.02 ticks)\n",
      "Probing time = 0.00 sec. (0.01 ticks)\n",
      "Clique table members: 15.\n",
      "MIP emphasis: balance optimality and feasibility.\n",
      "MIP search method: dynamic search.\n",
      "Parallel mode: deterministic, using up to 16 threads.\n",
      "Root relaxation solution time = 0.00 sec. (0.02 ticks)\n",
      "\n",
      "        Nodes                                         Cuts/\n",
      "   Node  Left     Objective  IInf  Best Integer    Best Bound    ItCnt     Gap\n",
      "\n",
      "*     0+    0                            0.0000      112.0000              --- \n",
      "*     0+    0                           41.0000      112.0000           173.17%\n",
      "      0     0       53.1111     4       41.0000       53.1111       11   29.54%\n",
      "*     0     0      integral     0       46.0000       Cuts: 7       17    0.00%\n",
      "      0     0        cutoff             46.0000       46.0000       17    0.00%\n",
      "Elapsed time = 1.15 sec. (0.19 ticks, tree = 0.01 MB, solutions = 3)\n",
      "\n",
      "Clique cuts applied:  3\n",
      "Cover cuts applied:  2\n",
      "Lift and project cuts applied:  1\n",
      "Gomory fractional cuts applied:  1\n",
      "\n",
      "Root node processing (before b&c):\n",
      "  Real time             =    1.17 sec. (0.20 ticks)\n",
      "Parallel b&c, 16 threads:\n",
      "  Real time             =    0.00 sec. (0.00 ticks)\n",
      "  Sync time (average)   =    0.00 sec.\n",
      "  Wait time (average)   =    0.00 sec.\n",
      "                          ------------\n",
      "Total (root+branch&cut) =    1.17 sec. (0.20 ticks)\n",
      "* GAP with no relaxation run OK, best objective is: 46\n"
     ]
    }
   ],
   "source": [
    "s = mdl.solve(url=url, key=key, log_output=True)\n",
    "assert s is not None\n",
    "obj = s.objective_value\n",
    "print(\"* GAP with no relaxation run OK, best objective is: {:g}\".format(obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a id=\"solve-model-lagrangian-relaxation\"></a>\n",
    "#### 4.5. Solve the model by using the Lagrangian Relaxation method\n",
    "\n",
    "To demonstrate the Lagrangian Relaxation method, let's consider that this model was hard to solve for CPLEX.\n",
    "We will approximate this problem by creating an iterative model where the objective is modified at each iteration. \n",
    "\n",
    "**Tip**: Wait a few seconds for the solution (due to a time limit parameter). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "First, we need to remove the culprit constraints from the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "for ct in cts:\n",
    "    mdl.remove_constraint(ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "As these constraints are removed, we need to ensure that they are satisfied by introducing new _penalization_ variables that hold the slack values of the constraints, and add the variables, with increased weight, to the objective."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "#p_vars are the penalties attached to violating the constraints\n",
    "p_vars = mdl.continuous_var_list(C, name='p')  # new for relaxation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# new version of the approximated constraint where we apply the penalties\n",
    "mdl.add_constraints(mdl.sum(xv) == 1 - pv for xv, pv in zip(x_vars, p_vars));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "#Define the maximum number of iterations\n",
    "max_iters = 10\n",
    "\n",
    "# define a new kpi\n",
    "total_profit = mdl.sum(mdl.scal_prod(x_i, c_i) for c_i, x_i in zip(C, x_vars))\n",
    "mdl.add_kpi(total_profit, \"Total profit\")\n",
    "\n",
    "\n",
    "number_of_cs = len(C)\n",
    "c_range = range(number_of_cs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Lagrangian relaxation main loop\n",
    "\n",
    "Lagrangian relaxation proceeds with a loop, with a maximum number of iterations. At each iteration, we want to:\n",
    "\n",
    "- solve the model, maximizing the sum of profit + penalty\n",
    "- if the constraints are satisfied, within a tolerance of 1e-6, stop\n",
    "- else, update penalization weights and solve again\n",
    "\n",
    "The algorithm stops when either all constraints are satisfied or the maximum number of iterations is reached."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* starting the loop, with a maximum 10 iterations\n",
      "1> new lagrangian iteration:\n",
      "\t obj=47, m=[1, 1, 1, 1, 1], p=[0, 0, 0, 0, 1.0]\n",
      "1> -- loop continues, m=[1.0, 1.0, 1.0, 1.0, 0.0], justifier=1\n",
      "2> new lagrangian iteration:\n",
      "\t obj=46, m=[1.0, 1.0, 1.0, 1.0, 0.0], p=[0, 0, 0, 0, 1.0]\n",
      "* Lagrangian relaxation succeeds, best=46, penalty=0, #iterations=2\n"
     ]
    }
   ],
   "source": [
    "# Langrangian relaxation main loop \n",
    "eps = 1e-6\n",
    "loop_count = 0\n",
    "best = 0\n",
    "initial_multiplier = 1\n",
    "multipliers = [initial_multiplier] * len(C)\n",
    "\n",
    "print(\"* starting the loop, with a maximum {0} iterations\".format(max_iters))\n",
    "while loop_count <= max_iters:\n",
    "    loop_count += 1\n",
    "    # Rebuilt at each loop iteration\n",
    "    total_penalty = mdl.scal_prod(p_vars, multipliers)\n",
    "    \n",
    "    mdl.maximize(total_profit + total_penalty)\n",
    "    s = mdl.solve(url=url, key=key)\n",
    "    if not s:\n",
    "        print(\"*** solve fails, stopping at iteration: %d\" % loop_count)\n",
    "        break\n",
    "    best = s.objective_value\n",
    "    penalties = [pv.solution_value for pv in p_vars]\n",
    "    print('%d> new lagrangian iteration:\\n\\t obj=%g, m=%s, p=%s' % (loop_count, best, str(multipliers), str(penalties)))\n",
    "\n",
    "    do_stop = True\n",
    "    justifier = 0\n",
    "    for k in c_range:\n",
    "        penalized_violation = penalties[k] * multipliers[k]\n",
    "        if penalized_violation >= eps:\n",
    "            do_stop = False\n",
    "            justifier = penalized_violation\n",
    "            break\n",
    "\n",
    "    if do_stop:\n",
    "        print(\"* Lagrangian relaxation succeeds, best={:g}, penalty={:g}, #iterations={}\"\n",
    "                .format(best, total_penalty.solution_value, loop_count))\n",
    "        break\n",
    "    else:\n",
    "        # Update multipliers and start the loop again.\n",
    "        scale_factor = 1.0 / float(loop_count)\n",
    "        multipliers = [max(multipliers[i] - scale_factor * penalties[i], 0.) for i in c_range]\n",
    "        print('{0}> -- loop continues, m={1!s}, justifier={2:g}'.format(loop_count, multipliers, justifier))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* optimal result of lagrangian relaxation is : 46.0, obtained in 2 iterations\n"
     ]
    }
   ],
   "source": [
    "print('* optimal result of lagrangian relaxation is : {0}, obtained in {1} iterations'.format(best, loop_count))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "<a id=\"Investigate-the-solution\"></a>\n",
    "### 6. Investigate the solution and run an example analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can see that with this relaxation method applied to our simple model we find the same solution to the problem as with the initial model.\n",
    "\n",
    "\n",
    "This example also demonstrates the use of Python to program complex workflows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Summary\n",
    "\n",
    "\n",
    "You learned how to set up and use IBM Decision Optimization CPLEX Modeling for Python to create a Constraint Programming model and solve it with IBM Decision Optimization on Cloud."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "render": true
   },
   "source": [
    "## References\n",
    "* [CPLEX Modeling for Python documentation](https://rawgit.com/IBMDecisionOptimization/docplex-doc/master/docs/index.html)\n",
    "* [Decision Optimization on Cloud](https://developer.ibm.com/docloud/)\n",
    "* [Decision Optimization documentation](https://datascience.ibm.com/docs/content/DO/DOinDSX.html)\n",
    "* For help with DOcplex, or to report a defect, go [here](https://developer.ibm.com/answers/smartspace/docloud).\n",
    "* Contact us at dofeedback@wwpdl.vnet.ibm.com\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<div class=\"alert alert-block alert-info\"> Note: To save resources and get the best performance please use the code below to stop the kernel before exiting your notebook.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%%javascript\n",
    "Jupyter.notebook.session.delete();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<hr>\n",
    "Copyright &copy; IBM Corp. 2017. Released as licensed Sample Materials."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "gist_id": "6011986",
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}