repository·main·Indexed 42 days ago
https://github.com/mobook/mo-bookCompanion Jupyter notebooks for the book 'Hands-On Mathematical Optimization with Python' (Cambridge University Press, 2025). This resource provides practical examples for mathematical optimization using Pyomo and the HiGHS solver, covering ConcreteModel construction, decision variables, objectives, constraints, and advanced techniques like matrix-form optimization and minimax linearization.
This repository contains the source Jupyter notebooks associated with the book Hands-On Mathematical Optimization with Python (Cambridge University Press, 2025). You can view the rendered collection of notebooks online at the official project website.
http://mobook.github.io/MO-book/To optimize the design of multiple insulation layers, you can formulate a Mixed Integer Quadratic Constraint Optimization (MIQCO) problem. This approach handles the trade-off between annual energy costs and capital installation costs.
Use pyo.ConcreteModel to define the set of layers, decision variables (including pyo.Binary for $y_n$), and the quadratic constraint m.R * m.U >= 1 for SCIP.
def insulate(df, alpha, beta, R0, T):
m = pyo.ConcreteModel()
m.N = pyo.Set(initialize=df.index)
a, b, k = df["a"], df["b"], df["k"]
# decision variables and physical bounds
Rmax = R0 + T / k.min()
m.R = pyo.Var(bounds=(R0, Rmax))
m.U = pyo.Var(bounds=(1 / Rmax, 1 / R0))
m.x = pyo.Var(m.N, bounds=(0, T))
m.y = pyo.Var(m.N, domain=pyo.Binary)
m.cost = pyo.Objective(
expr=alpha * m.U + beta * sum(a[n] * m.y[n] + b[n] * m.x[n] for n in m.N)
)
m.insulation = pyo.Constraint(expr=m.R == R0 + sum(m.x[n] / k[n] for n in m.N))
m.thickness = pyo.Constraint(expr=sum(m.x[n] for n in m.N) <= T)
m.layers = pyo.Constraint(m.N, rule=lambda m, n: m.x[n] <= T * m.y[n])
m.q = pyo.Constraint(expr=m.R * m.U >= 1)
return mThe PyomoMonad class manages the state of a Pyomo optimization workflow, including the model, any errors (status), and an optional reporting effect. It allows you to chain model construction, transformations, and solving steps while automatically handling exceptions.
.bind(func): Chains a function that accepts and returns a Pyomo model. If a previous step failed, subsequent bind calls are skipped.>>: An overloaded operator that acts as a shorthand for .bind().__call__(): Executes the monad. If an effect (reporting function) was provided during initialization, it runs that effect on the final model. Otherwise, it returns the model. If the workflow failed, it prints the captured exception.PyomoMonad(model, effect=report_func)..bind(transformer(...)) and .bind(solver(...)) to progress the model.# Example workflow using the >> operator
# ode_model_builder returns a PyomoMonad
# transformer('dae.collocation') and solver('ipopt') are wrapped functions
(soln := ode_model_builder() >> transformer('dae.collocation') >> solver('ipopt'))()
# Accessing results (assuming effect returns values)
tf, b = solnData-driven modeling in Pyomo involves decoupling the problem data from the mathematical structure. Instead of hard-coding values, you use:
This approach allows the model to scale automatically when the input data changes (e.g., adding a new product only requires updating the input dictionary, not the model logic).
# The pattern: Data -> Sets -> Params -> Vars/Constraints
products = {"U": {"price": 270, "demand": 40}}
model.PRODUCTS = pyo.Set(initialize=products.keys())
@model.Param(model.PRODUCTS)
def cp(model, p):
return products[p]["price"]For managing datasets associated with Pyomo models, use the Tidy Data approach. This ensures that data is structured predictably for reading, writing, and visualization.
Tidy Data Principles:
Implementation Patterns:
Example of Tidy Nested Dictionaries:
scenarios = {
"high": {"demand": 200, "price": 20},
"medium": {"demand": 100, "price": 18},
"low": {"demand": 50, "price": 15}
}In this structure, data is accessed via data[observation][variable] (e.g., scenarios["high"]["demand"]).
The preferred method for creating Pyomo model instances is using pyo.ConcreteModel. While pyo.AbstractModel allows for symbolic parameters to be defined before data is provided, pyo.ConcreteModel is more idiomatic when working within Python, as it allows you to use Python functions or classes to pass parameter values during model creation.
# Preferred approach: create a function that returns a ConcreteModel
def build_model(param_value):
model = pyo.ConcreteModel()
model.p = pyo.Param(initialize=param_value)
return modelWhen dealing with $n$-dimensional data (e.g., distances between multiple warehouses and customers), avoid wide tables where variables are spread across multiple columns. Instead, reorganize the data into a long format where every value is in a single column, indexed by multiple identifier columns.
Incorrect (Wide Format):
| Customer 1 | Customer 2 | |
|---|---|---|
| Warehouse A | 254 | 173 |
Correct (Tidy/Long Format):
| Warehouse | Customer | Distance |
|---|---|---|
| Warehouse A | Customer 1 | 254 |
| Warehouse A | Customer 2 | 173 |
This structure is easier to manipulate with tools like Pandas and prevents complex 'data wrangling' logic from being mixed into your Pyomo model building code.
For complex or repetitive modeling tasks, you can subclass pyo.ConcreteModel. This allows you to encapsulate the model building, solving, and reporting logic into a single reusable object.
When subclassing:
super().__init__() in __init__.build_model() method to define the Pyomo components (Sets, Params, Vars, etc.).class ProductionModel(pyo.ConcreteModel):
def __init__(self, products, resources, processes):
super().__init__("Production Model")
self.products = products
# ... store other data
def build_model(self):
# Define Pyomo components here using self.products, etc.
self.PRODUCTS = pyo.Set(initialize=self.products.keys())
# ...
def solve(self, solver):
self.build_model()
solver.solve(self)This chapter provides Pyomo implementations for various single-stage stochastic optimization problems. You can use these Jupyter notebooks to study modeling and implementation aspects of stochastic optimization through the following examples:
functional-programming-pyomo.ipynb notebook demonstrates how to apply functional programming styles to Pyomo. This is useful for integrating Pyomo into more complex optimization workflows or larger software projects where modularity and pure functions are preferred.To maintain consistency with Pyomo documentation and best practices, use pyo as the namespace for Pyomo imports. Avoid using from pyomo.environ import * as it is strongly discouraged. For teaching or presentations where a less verbose style is desired, explicitly import only the necessary objects.
# Preferred convention
import pyomo.environ as pyo
# For teaching/presentations (explicit imports)
from pyomo.environ import ConcreteModel, Var, Objective, maximize, SolverFactoryWhen optimization parameters (like demand, travel times, or stock levels) are subject to estimation, measurement, or implementation errors, you can inspect how sensitive your solutions are to these changes. This chapter provides two practical examples of performing sensitivity and robustness analysis:
For proactive modeling, refer to the following chapters: