Pyomo Quick Guide.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **1. Pyomo and Solvers Installation:**"
      ],
      "metadata": {
        "id": "ukWm5by8u3f4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "XcbzizjduaD0",
        "outputId": "080e4650-1383-41bd-9f9e-e79eaecfe707"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pyomo in /usr/local/lib/python3.10/dist-packages (6.8.0)\n",
            "Requirement already satisfied: ply in /usr/local/lib/python3.10/dist-packages (from pyomo) (3.11)\n"
          ]
        }
      ],
      "source": [
        "!pip install pyomo\n",
        "!apt-get install -y -qq glpk-utils   #glpk\n",
        "!apt-get install -y -qq coinor-cbc   #cbc\n",
        "\n",
        "from pyomo.environ import *"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget -N -q \"https://matematica.unipv.it/gualandi/solvers/ipopt-linux64.zip\"   #IPOPT\n",
        "!unzip -o -q ipopt-linux64"
      ],
      "metadata": {
        "id": "3gAvTlTn31VN"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install cplex -q   #cplex"
      ],
      "metadata": {
        "id": "7QuQ_UMDIkNl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2. Problem Definition:**"
      ],
      "metadata": {
        "id": "oBpOp-cevS8H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **`ConcreteModel()`**: Used when the entire model is defined at once.\n",
        "- **`AbstractModel()`**: Used when some parts of the model are defined later."
      ],
      "metadata": {
        "id": "voIDbJ6Ovdt3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = ConcreteModel()\n",
        "model1 = ConcreteModel()\n",
        "model2 = ConcreteModel()"
      ],
      "metadata": {
        "id": "19iHqclSvDsY"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **3. Defining Variables:**"
      ],
      "metadata": {
        "id": "VTRY-LibvvUP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The **`Var()`** function is used to declare variables in a Pyomo model.\n",
        "\n",
        "- `bounds`: The bounds parameter is used to specify the lower and upper limits for the variable. It is given as a tuple (lower_bound, upper_bound).\n",
        "- `within`: This parameter is used to specify the domain of the variable. It defines the set of values the variable is allowed to take.\n",
        "    - Common domains for variables in Pyomo:\n",
        "\n",
        "      - `Reals`: Any real number (positive, negative, or zero).\n",
        "      - `NonNegativeReals`: Real numbers that are greater than or equal to 0.\n",
        "      - `NonPositiveReals`: Real numbers that are less than or equal to 0.\n",
        "      - `Integers`: Whole numbers (positive, negative, or zero).\n",
        "      - `NonNegativeIntegers`: Whole numbers greater than or equal to 0.\n",
        "      - `Binary`: Variables that can only take the values 0 or 1 (often used in mixed-integer programming)."
      ],
      "metadata": {
        "id": "6jB264VcwtQm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.x = Var(bounds=(0, None), within=NonNegativeReals)\n",
        "model.y = Var(bounds=(0, None), within=NonNegativeReals)"
      ],
      "metadata": {
        "id": "whkUZQ8jvqQA"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Defining Indexed Variables:**\n",
        "\n",
        "In Pyomo, you use Sets to define the indices and Var to define the decision variables."
      ],
      "metadata": {
        "id": "WXTTDjyJ58Us"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the index set\n",
        "model1.indices = Set(initialize=['A', 'B', 'C'])\n",
        "\n",
        "# Define the decision variables d[i] for each i in indices\n",
        "# The decision variables have a lower bound of 0 and are continuous\n",
        "model1.d = Var(model1.indices, domain=NonNegativeReals)\n",
        "\n",
        "# Display the variables\n",
        "model1.pprint()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O9Crd6EG6bQB",
        "outputId": "417ca079-4e58-46d7-a386-c7a78bfd4287"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 Set Declarations\n",
            "    indices : Size=1, Index=None, Ordered=Insertion\n",
            "        Key  : Dimen : Domain : Size : Members\n",
            "        None :     1 :    Any :    3 : {'A', 'B', 'C'}\n",
            "\n",
            "1 Var Declarations\n",
            "    d : Size=3, Index=indices\n",
            "        Key : Lower : Value : Upper : Fixed : Stale : Domain\n",
            "          A :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "          B :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "          C :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "\n",
            "2 Declarations: indices d\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the sets for crops and areas\n",
        "model2.crops = Set(initialize=['sugar beets', 'cotton', 'sorghum'])\n",
        "model2.areas = Set(initialize=[1, 2, 3])\n",
        "\n",
        "# Define the decision variables x[crop, area]\n",
        "model2.x = Var(model2.crops, model2.areas, domain=NonNegativeReals)\n",
        "\n",
        "# Display the variables\n",
        "model2.x.pprint()  # This will show the variable names and their properties"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WZX2lSOa_8Gg",
        "outputId": "5a8c9c3d-1ec8-496c-d6b1-3ec667be4124"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x : Size=9, Index=crops*areas\n",
            "    Key                : Lower : Value : Upper : Fixed : Stale : Domain\n",
            "         ('cotton', 1) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "         ('cotton', 2) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "         ('cotton', 3) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "        ('sorghum', 1) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "        ('sorghum', 2) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "        ('sorghum', 3) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "    ('sugar beets', 1) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "    ('sugar beets', 2) :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "    ('sugar beets', 3) :     0 :  None :  None : False :  True : NonNegativeReals\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **4. Objective Function:**"
      ],
      "metadata": {
        "id": "tsbZ5-l5yBlB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To define an objective function, you use the **`Objective()`** function within your model. The general structure for defining an objective function in Pyomo is:\n",
        "\n",
        "`model.objective_name = Objective(expr=<expression>, sense=minimize/maximize)\n",
        "`"
      ],
      "metadata": {
        "id": "r4cTjG20yL8W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.obj = Objective(expr=2*model.x + 3*model.y, sense=minimize)"
      ],
      "metadata": {
        "id": "GT9ppdnNxtbp"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **5. Constraints:**"
      ],
      "metadata": {
        "id": "4YwcIviPzIng"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The general syntax for defining a constraint in Pyomo is:\n",
        "\n",
        "`model.constraint_name = Constraint(expr=<expression>)`\n",
        "\n",
        "- expr: This represents the mathematical expression of the constraint, involving variables and constants.\n",
        "\n",
        "- Comparison Operators:\n",
        "\n",
        "  Inequalities: Use <=, >= for \"less than or equal to\" and \"greater than or equal to.\"\n",
        "\n",
        "  Equalities: Use == for equality constraints."
      ],
      "metadata": {
        "id": "C0kAmYExzdz3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.constraint1 = Constraint(expr=2*model.x + model.y >= 1)\n",
        "model.constraint2 = Constraint(expr=model.x + 2*model.y >= 2)"
      ],
      "metadata": {
        "id": "_zmS12h7zDfe"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define constraints for each index\n",
        "def constraint_rule(model, i):\n",
        "    return model1.d[i] >= 10\n",
        "\n",
        "# Add constraints using the rule\n",
        "model1.constraints = Constraint(model1.indices, rule=constraint_rule)"
      ],
      "metadata": {
        "id": "RrTS00-27T4K"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model1.constraints.pprint()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i16p4cYa8CNa",
        "outputId": "8149d451-f96c-4448-89dc-f70c0d6b2e55"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "constraints : Size=3, Index=indices, Active=True\n",
            "    Key : Lower : Body : Upper : Active\n",
            "      A :  10.0 : d[A] :  +Inf :   True\n",
            "      B :  10.0 : d[B] :  +Inf :   True\n",
            "      C :  10.0 : d[C] :  +Inf :   True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **6. Solving the Problem:**"
      ],
      "metadata": {
        "id": "VA6XPfukz_aX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "After defining the model, you solve it using a solver.\n",
        "\n",
        "You can use various solvers depending on the problem:\n",
        "\n",
        "- Linear problems: glpk, cbc, gurobi, etc.\n",
        "- Nonlinear problems: ipopt, knitro, etc."
      ],
      "metadata": {
        "id": "NZgGzTOy0Hds"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "SolverFactory('glpk').solve(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hhLKh80J0D-W",
        "outputId": "2f97d67c-aacb-483a-9f8e-cebaccec8437"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Problem': [{'Name': 'unknown', 'Lower bound': 3.0, 'Upper bound': 3.0, 'Number of objectives': 1, 'Number of constraints': 2, 'Number of variables': 2, 'Number of nonzeros': 4, 'Sense': 'minimize'}], 'Solver': [{'Status': 'ok', 'Termination condition': 'optimal', 'Statistics': {'Branch and bound': {'Number of bounded subproblems': 0, 'Number of created subproblems': 0}}, 'Error rc': 0, 'Time': 0.011139392852783203}], 'Solution': [OrderedDict([('number of solutions', 0), ('number of solutions displayed', 0)])]}"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "SolverFactory('cplex_direct').solve(model)"
      ],
      "metadata": {
        "id": "MAIMpq2pI0Tb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **7. Extracting Results:**"
      ],
      "metadata": {
        "id": "bGNuy1B_0RzU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.display()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7nh0ZVam0Z5U",
        "outputId": "edcc1e9a-a046-4c97-a297-7de9ca30ed65"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model unknown\n",
            "\n",
            "  Variables:\n",
            "    x : Size=1, Index=None\n",
            "        Key  : Lower : Value : Upper : Fixed : Stale : Domain\n",
            "        None :     0 :   0.0 :  None : False : False : NonNegativeReals\n",
            "    y : Size=1, Index=None\n",
            "        Key  : Lower : Value : Upper : Fixed : Stale : Domain\n",
            "        None :     0 :   1.0 :  None : False : False : NonNegativeReals\n",
            "\n",
            "  Objectives:\n",
            "    obj : Size=1, Index=None, Active=True\n",
            "        Key  : Active : Value\n",
            "        None :   True :   3.0\n",
            "\n",
            "  Constraints:\n",
            "    constraint1 : Size=1\n",
            "        Key  : Lower : Body : Upper\n",
            "        None :   1.0 :  1.0 :  None\n",
            "    constraint2 : Size=1\n",
            "        Key  : Lower : Body : Upper\n",
            "        None :   2.0 :  2.0 :  None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get all variable names\n",
        "variable_names = model.component_objects(Var, active=True)\n",
        "\n",
        "# Print all variable names and their values\n",
        "for var in variable_names:\n",
        "    print(f\"Variable name: {var.name}, Value: {var.value}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QGJxvqK9-CnD",
        "outputId": "2a6166f2-f9a1-4d22-d08d-e8c63d8bdfd2"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variable name: x, Value: 2.00000000175489\n",
            "Variable name: y, Value: 3.00000000142049\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Display the results of the variables\n",
        "print(\"Variable values:\")\n",
        "print(f\"x = {model.x.value}\")\n",
        "print(f\"y = {model.y.value}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pg5HcZAs9Adg",
        "outputId": "7f6ed009-3ec9-42d9-bfe3-8e83514e98d9"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variable values:\n",
            "x = 0.0\n",
            "y = 1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Variable values:\")\n",
        "model1.d.pprint()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BQFnp7Py8oiB",
        "outputId": "901a4a00-4785-4a96-974b-f60bbfd728a8"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variable values:\n",
            "d : Size=3, Index=indices\n",
            "    Key : Lower : Value : Upper : Fixed : Stale : Domain\n",
            "      A :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "      B :     0 :  None :  None : False :  True : NonNegativeReals\n",
            "      C :     0 :  None :  None : False :  True : NonNegativeReals\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **8. Nonlinear Example:**"
      ],
      "metadata": {
        "id": "NI1k_kvN4csb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyomo.environ import *\n",
        "\n",
        "# Create a model\n",
        "model = ConcreteModel()\n",
        "\n",
        "# Define variables\n",
        "model.x = Var(bounds=(0, None))\n",
        "model.y = Var(bounds=(0, None))\n",
        "\n",
        "# Define objective function (nonlinear)\n",
        "model.obj = Objective(expr=(model.x - 2)**2 + (model.y - 3)**2, sense=minimize)\n",
        "\n",
        "# Define constraints (one of them is nonlinear)\n",
        "model.constr1 = Constraint(expr=model.x**2 + model.y >= 2)\n",
        "model.constr2 = Constraint(expr=model.x + model.y**2 >= 1)\n",
        "\n",
        "# Solve the model\n",
        "SolverFactory('ipopt', executable='ipopt').solve(model)\n",
        "\n",
        "# Display results\n",
        "model.display()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JLtFSEOs1PtV",
        "outputId": "fe73101f-4aac-4ab0-c9e7-4e753ff719d9"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model unknown\n",
            "\n",
            "  Variables:\n",
            "    x : Size=1, Index=None\n",
            "        Key  : Lower : Value            : Upper : Fixed : Stale : Domain\n",
            "        None :     0 : 2.00000000175489 :  None : False : False :  Reals\n",
            "    y : Size=1, Index=None\n",
            "        Key  : Lower : Value            : Upper : Fixed : Stale : Domain\n",
            "        None :     0 : 3.00000000142049 :  None : False : False :  Reals\n",
            "\n",
            "  Objectives:\n",
            "    obj : Size=1, Index=None, Active=True\n",
            "        Key  : Active : Value\n",
            "        None :   True : 5.097430643062936e-18\n",
            "\n",
            "  Constraints:\n",
            "    constr1 : Size=1\n",
            "        Key  : Lower : Body             : Upper\n",
            "        None :   2.0 : 7.00000000844005 :  None\n",
            "    constr2 : Size=1\n",
            "        Key  : Lower : Body              : Upper\n",
            "        None :   1.0 : 11.00000001027783 :  None\n"
          ]
        }
      ]
    }
  ]
}