authors/fdabrandao/examples/pattern_generation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Pattern Generation\n",
        "[![pattern_generation.ipynb](https://img.shields.io/badge/github-%23121011.svg?logo=github)](https://github.com/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb) [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb) [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb) [![Hits](https://h.ampl.com/https://github.com/ampl/colab.ampl.com/blob/master/authors/fdabrandao/examples/pattern_generation.ipynb)](https://colab.ampl.com)\n",
        "\n",
        "Description: Pattern generation example with amplpy\n",
        "\n",
        "Tags: amplpy, example\n",
        "\n",
        "Notebook author: Filipe Brandão <<fdabrandao@gmail.com>>\n",
        "\n",
        "Model author: N/A\n",
        "\n",
        "References: N/A"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Install dependencies\n",
        "%pip install -q amplpy matplotlib numpy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Google Colab & Kaggle integration\n",
        "from amplpy import AMPL, ampl_notebook\n",
        "\n",
        "ampl = ampl_notebook(\n",
        "    modules=[\"gurobi\"],  # modules to install\n",
        "    license_uuid=\"default\",  # license to use\n",
        ")  # instantiate AMPL object and register magics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Basic pattern-cutting model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "%%ampl_eval\n",
        "param nPatterns integer > 0;\n",
        "set PATTERNS = 1..nPatterns; # patterns\n",
        "set WIDTHS; # finished widths\n",
        "param order {WIDTHS} >= 0; # rolls of width j ordered\n",
        "param overrun; # permitted overrun on any width\n",
        "param rolls {WIDTHS,PATTERNS} >= 0 default 0; # rolls of width i in pattern j\n",
        "\n",
        "var Cut {PATTERNS} integer >= 0; # raw rolls to cut in each pattern\n",
        "\n",
        "minimize TotalRawRolls: sum {p in PATTERNS} Cut[p];\n",
        "\n",
        "subject to FinishedRollLimits {w in WIDTHS}:\n",
        "  order[w] <= sum {p in PATTERNS} rolls[w,p] * Cut[p] <= order[w] + overrun;"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Plotting routine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "def cuttingPlot(roll_width, widths, solution):\n",
        "    import numpy as np\n",
        "    import matplotlib.pyplot as plt\n",
        "\n",
        "    ind = np.arange(len(solution))\n",
        "    acc = [0] * len(solution)\n",
        "    for p, (patt, rep) in enumerate(solution):\n",
        "        for i in range(len(widths)):\n",
        "            for j in range(patt[i]):\n",
        "                vec = [0] * len(solution)\n",
        "                vec[p] = widths[i]\n",
        "                plt.bar(ind, vec, width=0.35, bottom=acc)\n",
        "                acc[p] += widths[i]\n",
        "    plt.title(\"Solution\")\n",
        "    plt.xticks(ind, tuple(\"x {:}\".format(rep) for patt, rep in solution))\n",
        "    plt.yticks(np.arange(0, roll_width, 10))\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Set data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "roll_width = 64.5\n",
        "overrun = 6\n",
        "orders = {6.77: 10, 7.56: 40, 17.46: 33, 18.76: 10}\n",
        "widths = list(sorted(orders.keys(), reverse=True))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Send data to AMPL (Java/C++ style)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [],
      "source": [
        "from math import floor\n",
        "\n",
        "# Send scalar values\n",
        "ampl.get_parameter(\"overrun\").set(overrun)\n",
        "ampl.get_parameter(\"nPatterns\").set(len(widths))\n",
        "# Send order vector\n",
        "ampl.get_set(\"WIDTHS\").set_values(widths)\n",
        "ampl.get_parameter(\"order\").set_values(orders)\n",
        "# Generate and send initial pattern matrix\n",
        "ampl.get_parameter(\"rolls\").set_values(\n",
        "    {(widths[i], 1 + i): int(floor(roll_width / widths[i])) for i in range(len(widths))}\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Send data to AMPL (alternative style)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Send scalar values\n",
        "ampl.param[\"overrun\"] = overrun\n",
        "ampl.param[\"nPatterns\"] = len(widths)\n",
        "# Send order vector\n",
        "ampl.set[\"WIDTHS\"] = widths\n",
        "ampl.param[\"order\"] = orders\n",
        "# Generate and send initial pattern matrix\n",
        "ampl.param[\"rolls\"] = {\n",
        "    (widths[i], 1 + i): int(floor(roll_width / widths[i])) for i in range(len(widths))\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Set up for generation loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Set solve options\n",
        "ampl.option[\"solver\"] = \"gurobi\"\n",
        "ampl.option[\"relax_integrality\"] = 1\n",
        "\n",
        "# Create a param for sending AMPL new patterns\n",
        "ampl.eval(\"param newpat {WIDTHS} integer >= 0;\")\n",
        "new_pattern = ampl.param[\"newpat\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define the knapsack subproblem"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Define the knapsack subproblem\n",
        "subprob = AMPL()\n",
        "subprob.option[\"solver\"] = \"gurobi\"\n",
        "subprob.eval(\n",
        "    \"\"\"\n",
        "    set WIDTHS;\n",
        "    param W >= 0;\n",
        "    param v{WIDTHS} >= 0;\n",
        "    var x{WIDTHS} integer >= 0;\n",
        "    maximize profit: sum {w in WIDTHS} v[w]*x[w];\n",
        "    subject to capacity: sum {w in WIDTHS} w*x[w] <= W;\n",
        "\"\"\"\n",
        ")\n",
        "subprob.set[\"WIDTHS\"] = widths\n",
        "subprob.param[\"W\"] = roll_width\n",
        "values = subprob.param[\"v\"]\n",
        "kpsolution = subprob.var[\"x\"]\n",
        "profit = subprob.obj[\"profit\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Master problem:\n",
            "Gurobi 9.5.0: optimal solution; objective 20.44444444\n",
            "\n",
            "Subproblem:\n",
            "Gurobi 9.5.0: optimal solution; objective 1.152777778\n",
            "1 simplex iterations\n",
            "1 branch-and-cut nodes\n",
            "\n",
            "Master problem:\n",
            "Gurobi 9.5.0: optimal solution; objective 18.77777778\n",
            "1 simplex iterations\n",
            "\n",
            "Subproblem:\n",
            "Gurobi 9.5.0: optimal solution; objective 1.111111111\n",
            "\n",
            "Master problem:\n",
            "Gurobi 9.5.0: optimal solution; objective 18.375\n",
            "3 simplex iterations\n",
            "\n",
            "Subproblem:\n",
            "Gurobi 9.5.0: optimal solution; objective 1.125\n",
            "1 simplex iterations\n",
            "1 branch-and-cut nodes\n",
            "\n",
            "Master problem:\n",
            "Gurobi 9.5.0: optimal solution; objective 17.95833333\n",
            "5 simplex iterations\n",
            "\n",
            "Subproblem:\n",
            "Gurobi 9.5.0: optimal solution; objective 1.041666667\n",
            "2 simplex iterations\n",
            "1 branch-and-cut nodes\n",
            "\n",
            "Master problem:\n",
            "Gurobi 9.5.0: optimal solution; objective 17.94117647\n",
            "5 simplex iterations\n",
            "\n",
            "Subproblem:\n",
            "Gurobi 9.5.0: optimal solution; objective 1\n",
            "1 simplex iterations\n",
            "1 branch-and-cut nodes\n",
            "\n"
          ]
        }
      ],
      "source": [
        "limits = ampl.get_constraint(\"FinishedRollLimits\")\n",
        "while True:\n",
        "    print(\"Master problem:\")\n",
        "    ampl.solve()\n",
        "    print()\n",
        "\n",
        "    # Retrieve duals & look for new pattern\n",
        "    # Solve knapsack problem for potential new pattern\n",
        "    values.set_values(limits.get_values())\n",
        "    print(\"Subproblem:\")\n",
        "    subprob.solve()\n",
        "    print()\n",
        "    if profit.value() <= 1.000001:\n",
        "        break\n",
        "\n",
        "    # Send new pattern to AMPL\n",
        "    new_pattern.set_values(kpsolution.get_values())\n",
        "    ampl.eval(\"let nPatterns := nPatterns + 1;\")\n",
        "    ampl.eval(\"let {w in WIDTHS} rolls[w, nPatterns] := newpat[w];\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Compute and display integer solution"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Gurobi 9.5.0: optimal solution; objective 19\n",
            "5 simplex iterations\n",
            "1 branch-and-cut nodes\n",
            "[0.0, 0.0, 0.0, 0.0, 10.0, 4.0, 4.0, 1.0]\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Compute and display integer solution\n",
        "ampl.option[\"relax_integrality\"] = 0\n",
        "ampl.solve()\n",
        "\n",
        "# Retrieve solution\n",
        "cutvec = ampl.var[\"Cut\"].to_list(skip_index=True)\n",
        "\n",
        "# Display solution\n",
        "rolls = ampl.param[\"rolls\"]\n",
        "npatterns = int(ampl.param[\"nPatterns\"].value())\n",
        "solution = [\n",
        "    ([int(rolls[widths[i], p]) for i in range(len(widths))], int(cutvec[p]))\n",
        "    for p in range(npatterns)\n",
        "    if cutvec[p] > 0\n",
        "]\n",
        "cuttingPlot(roll_width, widths, solution)"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.9.13 ('venv': venv)",
      "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.9.13"
    },
    "vscode": {
      "interpreter": {
        "hash": "ee4198aac13dae9b6fccd443041680d99c2643c4956ef7c80ff6dcc0057cb523"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}