Balance+inhouse+and+external+production+of+pasta+Local.ipynb

{
    "cells": [
        {
            "cell_type": "markdown", 
            "source": "# Balance in-house and external production of pasta\n\nThis tutorial includes information and data that you need to set up IBM Decision Optimization CPLEX Modeling for Python (DOcplex), build a mathematical programming (MP) model, and solve the model with IBM ILOG CPLEX Optimizer.\n\n\nWhen you finish this tutorial, you'll have a foundational knowledge of _Prescriptive Analytics_.\n\n>This notebook is part of [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\nSome familiarity with Python is recommended. This notebook runs on Python 2.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "## Describe the business problem\n\nThis notebook describes how to use CPLEX Modeling for Python to balance in-house and external production of pasta. The goal is to minimize the production cost for some pasta products and ensure that the customers' demand for the products is satisfied. \nThe following scenarios are considered: \n\n   * Each product can be either produced in-house, by the company itself, or outsourced to an external company at a higher cost.\n   * The in-house production is constrained by the resources, such as flour and eggs, while the external production is considered unlimited.\n\nTo investigate possible solutions, a mathematical programming (MP) model is built that declares the products and resources, and specifies the data and variables.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "## How  decision optimization can help \n\nPrescriptive 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 of business outcomes. For more information, go to the [Prescriptive analytics](https://ibm.com/software/products/sr/category/prescriptive-analytics) website.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "## Table of contents", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "1. [Download the library](#download_library)<br>\n2. [Set up the prescriptive engine](#set_prescriptive_engine)<br>\n3. [Model the data](#model_data)<br>\n4. [Set up the prescriptive model](#set_prescriptive_model)<br>\n    4.1 [Create the docplex model](#set_prescriptive_model_docplex)<br>\n    4.2 [Define the decision variables](#set_prescriptive_model_variables)<br>\n    4.3 [Define the business constraints](#set_prescriptive_model_constraints)<br>\n    4.4 [Specify the objective](#set_prescriptive_model_objective)<br>\n    4.5 [Solve the model](#set_prescriptive_model_solve)<br> \n5. [Investigate the solution and run a sample analysis](#investigate_solution)<br>", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"download_library\"></a>\n## 1. Download the library\n\nRun 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\nIn the following code, `real.prefix` is used to ensure that the script is not running inside a virtualenv environment.\n", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 1, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "import sys\ntry:\n    import docplex.mp\nexcept:\n    if hasattr(sys, 'real_prefix'):\n        !pip install docplex \n    else:\n        !pip install --user docplex"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_engine\"></a>\n## 2. Set up the prescriptive engine\n\n* Subscribe to your private Cloud offering, or to Decision Optimization on Cloud solve service [here](https://developer.ibm.com/docloud).\n\n* Get the Decision Optimization service URL and personal API key and enter them in the cell below, replacing the `None` values. Enclose the values in quotation marks (\" \"). For more information, go [here](https://developer.ibm.com/docloud/documentation/decision-optimization-on-cloud/api-key/).\n\n", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 2, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "url = None\nkey = None"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"model_data\"></a>\n## 3. Model the data\n\nThe data includes descriptions (demand, in-house and external production costs, resource consumption) of the different pasta products (kluski, capellini, fettucine), and the capacity of the resources (flour, eggs). Resources are a list of simple tuples (name, capacity).", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 3, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "products = [(\"kluski\", 100, 0.6, 0.8),\n            (\"capellini\", 200, 0.8, 0.9),\n            (\"fettucine\", 300, 0.3, 0.4)]\n\nresources = [(\"flour\", 20),\n             (\"eggs\", 40)]\n\nconsumptions = {(\"kluski\", \"flour\"): 0.5,\n                (\"kluski\", \"eggs\"): 0.2,\n                (\"capellini\", \"flour\"): 0.4,\n                (\"capellini\", \"eggs\"): 0.4,\n                (\"fettucine\", \"flour\"): 0.3,\n                (\"fettucine\", \"eggs\"): 0.6}"
        }, 
        {
            "cell_type": "markdown", 
            "source": "The data is very simple and ready to use without any cleansing or refactoring.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model\"></a>\n## 4. Set up the prescriptive model\n\nStart with viewing the environment information.", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 4, 
            "metadata": {}, 
            "outputs": [
                {
                    "output_type": "stream", 
                    "text": "* system is: Linux 64bit\n* Python is present, version is 2.7.11\n* docplex is present, version is (2, 3, 44)\n* CPLEX wrapper is not available\n", 
                    "name": "stdout"
                }
            ], 
            "source": "from docplex.mp.environment import Environment\nenv = Environment()\nenv.print_information()"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model_docplex\"></a>\n### 4.1 Create the docplex model  \n\nCPLEX Modeling for Python is used to build a mixed integer programming (MIP) model for this problem. In an MIP model, one or more variables must take integer solution values.\n\nThe model defines the decision variables, the business constraints, and the objective.", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 5, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "from docplex.mp.model import Model\nmdl = Model(name=\"pasta\")"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model_variables\"></a>\n###  4.2 Define the decision variables\n\nThe decision variables are:\n* `inside_vars` for in-house production\n* `outside_vars` for external production ", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 6, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "inside_vars = mdl.continuous_var_dict(products, name='inside')\noutside_vars = mdl.continuous_var_dict(products, name='outside')"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model_constraints\"></a>\n### 4.3 Define the business constraints \n\nThe constraints should address the following scenarios:\n   * Each pasta product can be produced either in-house or externally. \n   * The in-house production is constrained by the availability of resources, while the external production is considered unlimited\n\n", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 7, 
            "metadata": {
                "scrolled": true
            }, 
            "outputs": [
                {
                    "output_type": "stream", 
                    "text": "Model: pasta\n - number of variables: 6\n   - binary=0, integer=0, continuous=6\n - number of constraints: 5\n   - linear=5\n - parameters: defaults\n", 
                    "name": "stdout"
                }
            ], 
            "source": "# Demand satisfaction\nmdl.add_constraints((inside_vars[prod] + outside_vars[prod] >= prod[1], 'ct_demand_%s' % prod[0]) for prod in products)\n\n# Resource capacity\nmdl.add_constraints((mdl.sum(inside_vars[p] * consumptions[p[0], res[0]] for p in products) <= res[1], 'ct_res_%s' % res[0]) for res in resources)\n\nmdl.print_information()"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model_objective\"></a>\n### 4.4 Specify the objective \n\nThe objective is to minimize the production cost for a number of pasta products, and at the same time, ensure that the customers' demand is satisfied.\n\nIn the following code, `total_inside_cost` represents the total in-house production cost, and `total_outside_cost` represents the total external production cost.", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 8, 
            "metadata": {
                "collapsed": true
            }, 
            "outputs": [], 
            "source": "total_inside_cost = mdl.sum(inside_vars[p] * p[2] for p in products)\n\ntotal_outside_cost = mdl.sum(outside_vars[p] * p[3] for p in products)\n\nmdl.minimize(total_inside_cost + total_outside_cost)"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"set_prescriptive_model_solve\"></a>\n### 4.5 Solve the model\n\nNow, the model can be solved using the Decision Optimization solve service `Model.solve()`.\n\nThe following cell can also be solved using your local CPLEX optimizer, if you have one installed and added to your `PYTHONPATH` variable. \nIf you do not have CPLEX installed, enter your DOcplexcloud credentials in the `key` and `url` fields to solve on DOcplexcloud.", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 9, 
            "metadata": {
                "scrolled": true
            }, 
            "outputs": [
                {
                    "execution_count": 9, 
                    "metadata": {}, 
                    "output_type": "execute_result", 
                    "data": {
                        "text/plain": "docplex.mp.solution.SolveSolution(obj=372,values={inside_('kluski', 100,.."
                    }
                }
            ], 
            "source": "mdl.solve(url=url, key=key)"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<a id=\"investigate_solution\"></a>\n## 5. Investigate the solution and run a sample analysis", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 10, 
            "metadata": {
                "scrolled": true
            }, 
            "outputs": [
                {
                    "output_type": "stream", 
                    "text": "* Production model solved with objective: 372\n* Total inside cost=24\nInside production of kluski: 40.0\nInside production of capellini: 0\nInside production of fettucine: 0\n* Total outside cost=348\nOutside production of kluski: 60.0\nOutside production of capellini: 200.0\nOutside production of fettucine: 300.0\n", 
                    "name": "stdout"
                }
            ], 
            "source": "obj = mdl.objective_value\n\nprint(\"* Production model solved with objective: {:g}\".format(obj))\nprint(\"* Total inside cost=%g\" % total_inside_cost.solution_value)\nfor p in products:\n    print(\"Inside production of {product}: {ins_var}\".format(product=p[0], ins_var=inside_vars[p].solution_value))\nprint(\"* Total outside cost=%g\" % total_outside_cost.solution_value)\nfor p in products:\n    print(\"Outside production of {product}: {out_var}\".format(product=p[0], out_var=outside_vars[p].solution_value))"
        }, 
        {
            "cell_type": "markdown", 
            "source": "The proposed solution suggests in-house production of 40 units of kluski, and external production of 60 units of kluski, 200 units of capellini, and 300 units of fettucine.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "source": "## Summary\n\nYou've learned how to set up and use IBM Decision Optimization CPLEX Modeling for Python to create a mathematical programming model and solve it with IBM Decision Optimization on Cloud.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "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](http://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.", 
            "metadata": {}
        }, 
        {
            "cell_type": "markdown", 
            "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>", 
            "metadata": {}
        }, 
        {
            "cell_type": "code", 
            "execution_count": 11, 
            "metadata": {}, 
            "outputs": [
                {
                    "output_type": "display_data", 
                    "metadata": {}, 
                    "data": {
                        "application/javascript": "Jupyter.notebook.session.delete();", 
                        "text/plain": "<IPython.core.display.Javascript object>"
                    }
                }
            ], 
            "source": "%%javascript\nJupyter.notebook.session.delete();"
        }, 
        {
            "cell_type": "markdown", 
            "source": "<hr>\nCopyright &copy; IBM Corp. 2017. Released as licensed Sample Materials.", 
            "metadata": {}
        }
    ], 
    "nbformat": 4, 
    "metadata": {
        "kernelspec": {
            "language": "python", 
            "name": "python3-spark21", 
            "display_name": "Python 3.5 (Experimental) with Spark 2.1"
        }, 
        "language_info": {
            "version": "3.5.2", 
            "nbconvert_exporter": "python", 
            "mimetype": "text/x-python", 
            "name": "python", 
            "file_extension": ".py", 
            "pygments_lexer": "ipython3", 
            "codemirror_mode": {
                "version": 3, 
                "name": "ipython"
            }
        }
    }, 
    "nbformat_minor": 1
}