Model-Based Optimization / INFORMS International

Model-Based Optimization
INFORMS International 2018, Taipei — 18 June 2018
2
Best Practices and Current Trends
Robert Fourer
Northwestern University, AMPL Optimization Inc.
4er@northwestern.edu, 4er@ampl.com
INFORMS International Conference, Taipei, Taiwan
Tutorial Session MB06, 18 June 2018, 11:00-12:30

4

5

In general terms,
 Given a function of some decision variables
 Choose values of the variables to
make the function as large or as small as possible
 Subject to restrictions on the values of the variables
In practice,
 A paradigm for a very broad variety of problems
 A successful approach for finding solutions
6
Mathematical Optimization

Method-based vs. model-based approaches
 Example 1: Unconstrained optimization
 Example 2: Balanced assignment
 Example 3: Linear regression
Modeling languages for model-based optimization
 Executable languages
 Declarative languages
Solvers for model-based optimization
 “Linear” solvers
 “Nonlinear” solvers
 Other solver types
7
Outline: Model-Based Optimization

An example from calculus
 Min/Max 𝑓 𝑥 , . . . , 𝑥
. . . where 𝑓 is a smooth (differentiable) function
Approach #1
 Form 𝛻𝑓 𝑥 , . . . , 𝑥 0
 Find an expression for the solution to these equations
Approach #2
 Choose a starting point 𝐱 𝑥 , . . . , 𝑥
 Iterate 𝐱 𝐱 𝐝, where 𝛻 𝑓 𝐱 · 𝐝 𝛻𝑓 𝐱
. . . until the iterates converge
What makes these approaches different?
8
Example #1: Unconstrained Optimization

Approach #1: Method-oriented
 Finding an expression that solves 𝛻𝑓 𝑥 , . . . , 𝑥 0
. . . requires a different “method” for each new form of 𝑓
Approach #2: Model-oriented
 Choosing 𝑓 to model your problem
. . . the same iteration procedure applies to any 𝑓 and 𝐱
. . . can be implemented by general, off-the-shelf software
Am I leaving something out?
 To solve 𝛻 𝑓 𝐱 · 𝐝 𝛻𝑓 𝐱 ,
you need to form 𝛻 and 𝛻 for the given 𝑓
9
Where You Put the Most Effort
What makes these approaches different?

Modeling
 Describing of 𝑓 as a function of variables
Evaluation
 Computing 𝑓 𝐱 from the description
 Computing 𝛻𝑓 𝐱 , 𝛻 𝑓 𝐱 by automatic differentiation
Solution
 Applying the iterative algorithm
 Computing the iterates
 Testing for convergence
Send to an off-the-shelf solver?
 Choice of excellent smooth constrained nonlinear solvers
 Differentiable unconstrained optimization is a special case
10
No . . . Software Can Handle Everything
Am I leaving something out?

A small test case for solvers
 https://en.wikipedia.org/wiki/Shekel_function
11
Example 1a: Shekel Function

Given
𝑚 number of locally optimal points
𝑛 number of variables
and
𝑎 for each 𝑖 1, . . . , 𝑚 and 𝑗 1, . . . , 𝑛
𝑐 for each 𝑖 1, . . . , 𝑚
Determine
𝑥𝑗 for each 𝑗 1, . . . , 𝑛
to maximize
∑ 1/ 𝑐 ∑ 𝑥 𝑎
12
Mathematical Formulation

13
Modeling Language Formulation
Symbolic model (AMPL)
param m integer > 0;
param n integer > 0;
param a {1..m, 1..n};
param c {1..m};
var x {1..n};
maximize objective:
sum {i in 1..m} 1 / (c[i] + sum {j in 1..n} (x[j] - a[i,j])^2);
∑ 1/ 𝑐 ∑ 𝑥 𝑎

14
Modeling Language Data
Explicit data (independent of model)
param m := 5 ;
param n := 4 ;
param a: 1 2 3 4 :=
1 4 4 4 4
2 1 1 1 1
3 8 8 8 8
4 6 6 6 6
5 3 7 3 7 ;
param c :=
1 0.1
2 0.2
3 0.2
4 0.4
5 0.4 ;

15
Modeling Language Solution
Model + data = problem instance to be solved
ampl: model shekelEX.mod;
ampl: data shekelEX.dat;
ampl: option solver knitro;
ampl: solve;
Knitro 10.3.0: Locally optimal solution.
objective 5.055197729; feasibility error 0
6 iterations; 9 function evaluations
ampl: display x;
x [*] :=
1 1.00013
2 1.00016
3 1.00013
4 1.00016
;

16
. . . again with multistart option
ampl: option knitro_options 'ms_enable=1 ms_maxsolves=100';
ampl: solve;
objective 10.15319968; feasibility error 0
ampl: display x;
x [*] :=
1 4.00004
2 4.00013
3 4.00004
4 4.00013
;

17
Solution (cont’d)
. . . again with a “global” solver
ampl: option solver baron;
ampl: solve;
BARON 17.10.13 (2017.10.13):
43 iterations, optimal within tolerances.
Objective 10.15319968
ampl: display x;
x [*] :=
1 4.00004
2 4.00013
3 4.00004
4 4.00013
;

18
Example 1b: Protein Folding
Objective
 For a given protein molecule,
find the configuration that has lowest energy
 Sum of 6 energy expressions defined in terms of variables
Variables
 Decision variables: positions of atoms
 Variables defined in terms of other variables: 22 kinds
Data
 8 index sets
 30 collections of parameters, indexed over various sets

19
Problem variables & some defined variables
var x {i in Atoms, j in D3} := x0[i,j];
var aax {i in Angles, j in D3} = x[it[i],j] - x[jt[i],j];
var abx {i in Angles, j in D3} = x[kt[i],j] - x[jt[i],j];
var a_axnorm {i in Angles} = sqrt(sum{j in D3} aax[i,j]^2);
var a_abdot {i in Angles} = sum {j in D3} aax[i,j]*abx[i,j];
.......
var cosphi {i in Torsions} = (sum{j in D3} ax[i,j]*bx[i,j])
/ sqrt(sum{j in D3} ax[i,j]^2)
/ sqrt(sum{j in D3} bx[i,j]^2);
var term {i in Torsions} = if np[i] == 1 then cosphi[i]
else if np[i] == 2 then 2*cosphi[i]^2 — 1
else 4*cosphi[i]^3 - 3*cosphi[i];

20
Some more defined variables
var rinv14{i in Pairs14} =
1. / sqrt( sum{j in D3} (x[i14[i],j] - x[j14[i],j])^2 );
var r614{i in Pairs14} =
((sigma[i14[i]] + sigma[j14[i]]) * rinv14[i]) ^ 6;
var rinv{i in Pairs} =
1. / sqrt( sum{j in D3} (x[inb[i],j] - x[jnb[i],j])^2 );
var r6{i in Pairs} =
((sigma[inb[i]] + sigma[jnb[i]]) * rinv[i]) ^ 6;

21
Components of total energy
var bond_energy = sum {i in Bonds} fcb[i] *
(sqrt( sum {j in D3} (x[ib[i],j] - x[jb[i],j])^2 ) - b0[i] ) ^ 2
var angle_energy = sum {i in Angles} fct[i] *
(atan2 (sqrt( sum{j in D3}
(abx[i,j]*a_axnorm[i] - a_abdot[i]/a_axnorm[i]*aax[i,j])^2),
a_abdot[i] ) - t0[i]) ^ 2
var torsion_energy =
sum {i in Torsions} fcp[i]*(1 + cos(phase[i])*term[i])
var improper_energy =
sum {i in Improper} (fcr[i] * idi[i]^2);

22
Components of total energy (cont’d)
var pair14_energy =
sum {i in Pairs14} ( 332.1667*q[i14[i]]*q[j14[i]]*rinv14[i]*0.5
+ sqrt(eps[i14[i]]*eps[j14[i]])*(r614[i]^2 - 2*r614[i]) );
var pair_energy =
sum{i in Pairs} ( 332.1667*q[inb[i]]*q[jnb[i]]*rinv[i]
+ sqrt(eps[inb[i]]*eps[jnb[i]])*(r6[i]^2 - 2*r6[i]) );
minimize energy:
bond_energy + angle_energy + torsion_energy +
improper_energy + pair14_energy + pair_energy;

23
Excerpts from parameter tables
param x0: 1 2 3 :=
1 0 0 0
2 1.0851518862529654 0 0
3 -0.35807838634224287 1.021365666308466 0
4 -0.36428404194337122 -0.50505976829103794 -0.90115715381950734
5 -0.52386736173121617 -0.69690490803763017 1.2465998798976687
.......
param: ib jb fcb b0 :=
1 1 2 340.000000 1.09000000
2 1 3 340.000000 1.09000000
3 1 4 340.000000 1.09000000
.......
param : inb jnb :=
1 1 10
2 1 11
3 1 12
.......

24
Solution
Local optimum from Knitro run
ampl: model pfold.mod;
ampl: data pfold3.dat;
ampl: option show_stats 1;
ampl: solve;
Substitution eliminates 762 variables.
Adjusted problem:
66 variables, all nonlinear
0 constraints
1 nonlinear objective; 66 nonzeros.
objective -32.38835099; feasibility error 0

25
Solution
Local optimum from Knitro multistart run
ampl: model pfold.mod;
ampl: data pfold3.dat;
ampl: knitro_options 'ms_enable=1 ms_maxsolves=100';
ampl: solve;
Knitro 10.3.0: ms_enable=1
ms_maxsolves=100
objective -32.39148536; feasibility error 0

26
Solution
Details from Knitro run
Number of nonzeros in Hessian: 2211
Iter Objective FeasError OptError ||Step|| CGits
0 -2.777135e+001 0.000e+000
1 -2.874955e+001 0.000e+000 1.034e+001 5.078e-001 142
2 -2.890054e+001 0.000e+000 1.361e+001 1.441e+000 0
...
11 -3.238833e+001 0.000e+000 6.225e-002 9.557e-002 0
12 -3.238835e+001 0.000e+000 8.104e-004 3.341e-003 0
13 -3.238835e+001 0.000e+000 8.645e-009 1.390e-005 0
# of function evaluations = 20
# of gradient evaluations = 14
# of Hessian evaluations = 13
Total program time (secs) = 0.022
Time spent in evaluations (secs) = 0.009

Example #2: Balanced Assignment
Motivation
 meeting of employees from around the world
Given
 several employee categories
(title, location, department, male/female)
 a specified number of project groups
Assign
 each employee to a project group
So that
 the groups have about the same size
 the groups are as “diverse” as possible with respect to all categories
27

Method-Based Approach
Define an algorithm to build a balanced assignment
 Start with all groups empty
 Make a list of people (employees)
 For each person in the list:
 Add to the group whose resulting “sameness” will be least
Balanced Assignment
Initialize all groups G = { }
Repeat for each person p
sMin = Infinity
Repeat for each group G
s = total "sameness" in G ∪ {p}
if s < sMin then
sMin = s
GMin = G
Assign person p to group GMin
28

Method-Based Approach (cont’d)
Define a computable concept of “sameness”
 Sameness of a pair of people:
 Number of categories in which they are the same
 Sameness in a group:
 Sum of the sameness of all pairs of people in the group
Refine the algorithm to get better results
 Reorder the list of people
 Locally improve the initial “greedy” solution
by swapping group members
 Seek further improvement through
local search metaheuristics
 What are the neighbors of an assignment?
 How can two assignments combine to create a better one?
Balanced Assignment
29

Model-Based Approach
Formulate a “minimal sameness” model
 Define decision variables for assignment of people to groups
 𝑥 1 if person 1 assigned to group 𝑗
 𝑥 0 otherwise
 Specify valid assignments through constraints on the variables
 Formulate sameness as an objective to be minimized
 Total sameness = sum of the sameness of all groups
Send to an off-the-shelf solver
 Choice of excellent linear-quadratic mixed-integer solvers
 Zero-one optimization is a special case
Balanced Assignment
30

Model-Based Formulation
Given
𝑃 set of people
𝐶 set of categories of people
𝑡 type of person 𝑖 within category 𝑘, for all 𝑖 ∈ 𝑃, 𝑘 ∈ 𝐶
and
𝐺 number of groups
𝑔 lower limit on people in a group
𝑔 upper limit on people in a group
Define
𝑠 | 𝑘 ∈ 𝐶: 𝑡 𝑡 |, for all 𝑖 ∈ 𝑃, 𝑖 ∈ 𝑃
sameness of persons 𝑖 and 𝑖
Balanced Assignment
31

Determine
𝑥 ∈ 0,1 1 if person 𝑖 is assigned to group 𝑗
0 otherwise, for all 𝑖 ∈ 𝑃, 𝑗 1, . . . , 𝐺
To minimize
∑ ∑ 𝑠 ∑ 𝑥∈ 𝑥∈
total sameness of all pairs of people in all groups
Subject to
∑ 𝑥 1, for each 𝑖 ∈ 𝑃
each person must be assigned to one group
𝑔 ∑ 𝑥∈ 𝑔 , for each 𝑗 1, . . . , 𝐺
each group must be assigned an acceptable number of people
32
Model-Based Formulation (cont’d)
Balanced Assignment

Model-Based Solution
Optimize with an off-the-shelf solver
Choose among many alternatives
 Linearize and send to a mixed-integer linear solver
 CPLEX, Gurobi, Xpress; CBC
 Send quadratic formulation to a mixed-integer solver
that automatically linearizes products involving binary variables
 CPLEX, Gurobi, Xpress
 Send quadratic formulation to a nonlinear solver
 Mixed-integer nonlinear: Knitro, BARON
 Continuous nonlinear (might come out integer): MINOS, Ipopt, . . .
Balanced Assignment
33

Where Is the Work?
Method-based
 Programming an implementation of the method
Model-based
 Constructing a formulation of the model
Balanced Assignment
34

Complications in Balanced Assignment
“Total Sameness” is problematical
 Hard for client to relate to goal of diversity
 Minimize “total variation” instead
 Sum over all types: most minus least assigned to any group
Client has special requirements
 No employee should be “isolated” within their group
 No group can have exactly one woman
 Every person must have a group-mate
from the same location and of equal or adjacent rank
Room capacities are variable
 Different groups have different size limits
 Minimize “total deviation”
 Sum over all types: greatest violation of target range for any group
35

Method-Based (cont’d)
Revise or replace the original solution approach
 Total variation is less suitable to a greedy algorithm
Re-think improvement procedures
 Total variation is harder to locally improve
 Client constraints are challenging to enforce
Update or re-implement the method
 Even small changes to the problem can necessitate
major changes to the method and its implementation
Balanced Assignment
36

Add variables
𝑦 fewest people of category 𝑘, type 𝑙 in any group,
𝑦 most people of category 𝑘, type 𝑙 in any group,
for each 𝑘 ∈ 𝐶, 𝑙 ∈ 𝑇 ⋃ 𝑡∈
Add defining constraints
𝑦 ∑ 𝑥∈ : , for each 𝑗 1, . . . , 𝐺; 𝑘 ∈ 𝐶, 𝑙 ∈ 𝑇
Minimize total variation
∑ ∑ 𝑦∈∈ 𝑦 )
. . . generalizes to handle varying group sizes
37
Model-Based (cont’d)
Balanced Assignment

To express client requirement for women in a group, let
𝑄 𝑖 ∈ 𝑃: 𝑡 , ⁄ female
Add constraints
∑ 𝑥 0∈ or ∑ 𝑥 2∈ , for each 𝑗 1, . . . , 𝐺
Balanced Assignment
38

To express client requirement for women in a group, let
𝑄 𝑖 ∈ 𝑃: 𝑡 , ⁄ female
Define logic variables
𝑧 ∈ 0,1 1 if any women assigned to group 𝑗
0 otherwise, for all 𝑗 1, . . . , 𝐺
Add constraints relating logic to assignment variables
2𝑧 ∑ 𝑥 𝑄 𝑧∈ , for each 𝑗 1, . . . , 𝐺
Balanced Assignment
39

To express client requirements for group-mates, let
𝑃 𝑖 ∈ 𝑃: 𝑡 , 𝑙 , 𝑡 , 𝑙 , for all 𝑙 ∈ 𝑇 , 𝑙 ∈ 𝑇
𝐴 ⊆ 𝑇 ranks adjacent to rank 𝑙, for all 𝑙 ∈ 𝑇
Add constraints
∑ 𝑥 0∈ or ∑ 𝑥 ∑ ∑ 𝑥 2∈∈∈ ,
for each 𝑙 ∈ 𝑇 , 𝑙 ∈ 𝑇 , 𝑗 1, . . . , 𝐺
Balanced Assignment
40

To express client requirements for group-mates, let
𝑃 𝑖 ∈ 𝑃: 𝑡 , 𝑙 , 𝑡 , 𝑙 , for all 𝑙 ∈ 𝑇 , 𝑙 ∈ 𝑇
𝐴 ⊆ 𝑇 ranks adjacent to rank 𝑙, for all 𝑙 ∈ 𝑇
Define logic variables
𝑤 ∈ 0,1 1 if group 𝑗 has anyone from location 𝑙 of rank 𝑙
0 otherwise, for all 𝑙 ∈ 𝑇 , 𝑙 ∈ 𝑇 , 𝑗 1, . . . , 𝐺
Add constraints relating logic to assignment variables
𝑤 ∑ 𝑥 𝑃 𝑤∈ ,
∑ 𝑥 ∑ ∑ 𝑥 2𝑤∈∈∈ ,
for each 𝑙 ∈ 𝑇 , 𝑙 ∈ 𝑇 , 𝑗 1, . . . , 𝐺
Balanced Assignment
41

Given
 Observed vector 𝐲
 Regressor vectors 𝐱 , 𝐱 , . . . , 𝐱
Choose multipliers 𝛽 , 𝛽 , . . . , 𝛽 to . . .
 Approximate 𝐲 by ∑ 𝐱 𝛽
 Explain 𝐲 convincingly
42
Example #3: Linear Regression

Iteratively improve choice of regressors
 Repeat
 Solve a minimum-error problem using a subset of the regressors
 Remove and re-add regressors as suggested by results
 Until remaining regressors are judged satisfactory
Results are varied
 Depends on interpretation and judgement of results
 “As much an art as a science”
43
Method-Based (traditional)

Define a “best” choice of regressors
 Build a mixed-integer optimization model
 Objective function minimizes error
 Constraints specify desired properties of the regressor set
Optimize with an off-the-shelf solver
 Many excellent choices available
 Linear-quadratic mixed-integer
 General nonlinear mixed-integer
44
Model-Based
Dimitris Bertsimas and Angela King,
“An Algorithmic Approach to Linear Regression.”
Operations Research 64 (2016) 2–16.

Given
𝑚 number of observations
𝑛 number of regressors
and
𝑦 observations, for each 𝑖 1, . . . , 𝑚
𝑥 regressor values corresponding to observation 𝑖,
for each 𝑗 1, . . . , 𝑛 and 𝑖 1, . . . , 𝑚
45
Algebraic Formulation
Linear Regression

Determine
𝛽 Multiplier for regressor 𝑗, for each 𝑗 1, . . . , 𝑛
𝑧 1 if 𝛽 0: regressor 𝑗 is used,
0 if 𝛽 0: regressor 𝑗 is not used, for each 𝑗 1, . . . , 𝑛
to minimize
∑ 𝑦 ∑ 𝑥 𝛽 Γ ∑ 𝛽
Sum of squared errors
plus “lasso” term for regularization and robustness
46
Linear Regression

Subject to
𝑀𝑧 𝛽 𝑀𝑧 for all 𝑗 1, . . . , 𝑛
If the 𝑗 regressor is used then 𝑧 1
(where 𝑀 is a reasonable bound on 𝛽 )
∑ 𝑧 𝑘
At most 𝑘 regressors may be used
𝑧 . . . 𝑧 for 𝑗 , . . . , 𝑗 ∈ 𝒢𝒮 , 𝑝 1, . . . , 𝑛 𝒢𝒮
All regressors in each group sparsity set 𝒢𝒮
are either used or not used
𝑧 𝑧 1 for all 𝑗 , 𝑗 ∈ ℋ𝒞
For any pair of highly collinear regressors,
only one may be used
47
Linear Regression

Subject to
∑ 𝑧 1∈𝒯 for all 𝑝 1, . . . , 𝑛 𝒯
For a regressor and any of its transformations,
only one may be used
𝑧 1 for all 𝑗 ∈ ℐ
Specified regressors must be used
∑ 𝑧 𝒮 1∈ for all 𝑝 1, . . . , 𝑛
Exclude previous solutions using 𝛽 , 𝑗 ∈ 𝑆
48
Linear Regression

Problems hard to formulate for off-the-shelf solvers
 “Logic” constraints
 sequencing, scheduling, cutting, packing
 “Black box” functions
 simulations, approximations
Large, specialized applications
 Routing delivery trucks nationwide
 Finding shortest routes in mapping apps
Metaheuristic schemes
 Evolutionary methods, simulated annealing, . . .
Artificial intelligence and related computer science
 Constraint programming
 Training deep neural networks
49
Method-Based Remains Popular for . . .

Diverse application areas
 Operations research & management science
 Business analytics
 Engineering & science
 Economics & finance
Diverse kinds of users
 Anyone who took an “optimization” class
 Anyone else with a technical background
 Newcomers to optimization
These have in common . . .
 Good algebraic formulations for off-the-shelf solvers
 Users focused on modeling
50
Model-Based Has Become Standard for . . .

Off-the-shelf solvers keep improving
 Solve the same problems faster and faster
 Handle broader problem classes
 Recognize special cases automatically
Optimization has become more model-based
 Off-the-shelf solvers for constraint programming
 Model-based metaheuristics (“Matheuristics”)
Hybrid approaches have become easier to build
 Model-based APIs for solvers
 APIs for algebraic modeling systems
51
Trends Favor Model-Based Optimization

Background
 The modeling lifecycle
 Matrix generators
 Modeling languages
Algebraic modeling languages
 Design approaches: declarative, executable
 Example: AMPL vs. gurobipy
 Survey of available software
Balanced assignment model in AMPL
 Formulation
 Solution
52
Modeling Languages
for Model-Based Optimization

53
The Optimization Modeling Lifecycle
Communicate with Client
Build Model
Generate Optimization Problem
Submit Problem to Solver
Report & Analyze Results
Prepare Data

Goals for optimization software
 Repeat the cycle quickly and reliably
 Get results before client loses interest
 Deploy for application
Complication: two forms of an optimization problem
 Modeler’s form
 Mathematical description, easy for people to work with
 Solver’s form
 Explicit data structure, easy for solvers to compute with
Challenge: translate between these two forms
54
Managing the Modeling Lifecycle

Write a program to generate the solver’s form
 Read data and compute objective & constraint coefficients
 Communicate with the solver via its API
 Convert the solver’s solution for viewing or processing
Some attractions
 Ease of embedding into larger systems
 Access to advanced solver features
Serious disadvantages
 Difficult environment for modeling
 program does not resemble the modeler’s form
 model is not separate from data
 Very slow modeling cycle
 hard to check the program for correctness
 hard to distinguish modeling from programming errors
55
Matrix Generators

[1980]Over the past seven years we have perceived that the size
distribution of general structure LP problems being run on commercial LP
codes has remained about stable. . . . A 3000 constraint LP model is still
considered large and very few LP problems larger than 6000 rows are being
solved on a production basis. . . . That this distribution has not noticeably
changed despite a massive change in solution economics is unexpected.
We do not feel that the linear programming user’s most pressing need over the
next few years is for a new optimizer that runs twice as fast on a machine that
costs half as much (although this will probably happen). Cost of optimization
is just not the dominant barrier to LP model implementation. The process
required to manage the data, formulate and build the model, report on and
analyze the results costs far more, and is much more of a barrier to effective
use of LP, than the cost/performance of the optimizer.
Why aren’t more larger models being run? It is not because they could not be
useful; it is because we are not successful in using them. . . . They become
unmanageable. LP technology has reached the point where anything that can
be formulated and understood can be optimized at a relatively modest cost.
C.B. Krabek, R.J. Sjoquist and D.C. Sommer, The APEX Systems: Past and Future.
SIGMAP Bulletin 29 (April 1980) 3–23.
56

Describe your model
 Write your symbolic model in a
computer-readable modeler’s form
 Prepare data for the model
 Let computer translate to & from the solver’s form
Limited drawbacks
 Need to learn a new language
 Incur overhead in translation
 Make formulations clearer and hence easier to steal?
Great advantages
 Faster modeling cycles
 More reliable modeling
 More maintainable applications
57
Modeling Languages

[1982]The aim of this system is to provide one representation of a model
which is easily understood by both humans and machines. . . . With such a
notation, the information content of the model representation is such that a
machine can not only check for algebraic correctness and completeness, but
also interface automatically with solution algorithms and report writers.
. . . a significant portion of total resources in a modeling exercise . . . is spent
on the generation, manipulation and reporting of models. It is evident that this
must be reduced greatly if models are to become effective tools in planning
and decision making.
The heart of it all is the fact that solution algorithms need a data structure
which, for all practical purposes, is impossible to comprehend by humans,
while, at the same time, meaningful problem representations for humans are
not acceptable to machines. We feel that the two translation processes
required (to and from the machine) can be identified as the main source of
difficulties and errors. GAMS is a system that is designed to eliminate these
two translation processes, thereby lifting a technical barrier to effective
modeling . . .
J. Bisschop and A. Meeraus, On the Development of a General Algebraic Modeling System in
a Strategic Planning Environment. Mathematical Programming Study 20 (1982) 1–29.
58

[1983]These two forms of a linear program — the modeler’s form
and the algorithm’s form — are not much alike, and yet neither can be
done without. Thus any application of linear optimization involves
translating the one form to the other. This process of translation has long
been recognized as a difficult and expensive task of practical linear
programming.
In the traditional approach to translation, the work is divided between
modeler and machine. . . .
There is also a quite different approach to translation, in which as much
work as possible is left to the machine. The central feature of this
alternative approach is a modeling language that is written by the modeler
and translated by the computer. A modeling language is not a
programming language; rather, it is a declarative language that expresses
the modeler’s form of a linear program in a notation that a computer
system can interpret.
R. Fourer, Modeling Languages Versus Matrix Generators for Linear Programming.
ACM Transactions on Mathematical Software 9 (1983) 143–183.
59

Designed for a model-based approach
 Define data in terms of sets & parameters
 Analogous to database keys & records
 Define decision variables
 Minimize or maximize a function of decision variables
 Subject to equations or inequalities
that constrain the values of the variables
Advantages
 Familiar
 Powerful
 Proven
60
Algebraic Modeling Languages

Design alternatives
 Executable: object libraries for programming languages
 Declarative: specialized optimization languages
Design comparison
 Executable versus declarative using one simple example
Survey
 Solver-independent vs. solver-specific
 Proprietary vs. free
 Notable specific features
61
Overview

Concept
 Create an algebraic modeling language
inside a general-purpose programming language
 Redefine operators like + and <=
to return constraint objects rather than simple values
Advantages
 Ready integration with applications
 Good access to advanced solver features
Disadvantages
 Programming issues complicate description of the model
 Modeling and programming bugs are hard to separate
 Efficiency issues are more of a concern
62
Executable

Concept
 Design a language specifically for optimization modeling
 Resembles mathematical notation as much as possible
 Extend to command scripts and database links
 Connect to external applications via APIs
Disadvantages
 Adds a system between application and solver
 Does not have a full object-oriented programming framework
Advantages
 Streamlines model development
 Promotes validation and maintenance of models
 Works with many popular programming languages
63
Declarative

Two representative widely used systems
 Executable: gurobipy
 Python modeling interface for Gurobi solver
 http://gurobi.com
 Declarative: AMPL
 Specialized modeling language with multi-solver support
 http://ampl.com
64
Comparison: Executable vs. Declarative

65
Data
gurobipy
 Assign values to Python
lists and dictionaries
commodities = ['Pencils', 'Pens']
nodes = ['Detroit', 'Denver',
'Boston', 'New York', 'Seattle']
arcs, capacity = multidict({
('Detroit', 'Boston'): 100,
('Detroit', 'New York’): 80,
('Detroit', 'Seattle’): 120,
('Denver’, 'Boston'): 120,
('Denver’, 'New York'): 120,
('Denver’, 'Seattle’): 120 })
Comparison
AMPL
 Define symbolic model
sets and parameters
set COMMODITIES := Pencils Pens ;
set NODES := Detroit Denver
Boston 'New York' Seattle ;
param: ARCS: capacity:
Boston 'New York' Seattle :=
Detroit 100 80 120
Denver 120 120 120 ;
set COMMODITIES;
set NODES;
set ARCS within {NODES,NODES};
param capacity {ARCS} >= 0;
 Provide data later
in a separate file

66
Data (cont’d)
gurobipy
inflow = {
('Pencils', 'Detroit'): 50,
('Pencils', 'Denver'): 60,
('Pencils', 'Boston'): -50,
('Pencils', 'New York'): -50,
('Pencils', 'Seattle'): -10,
('Pens', 'Detroit'): 60,
('Pens', 'Denver'): 40,
('Pens', 'Boston'): -40,
('Pens', 'New York'): -30,
('Pens', 'Seattle'): -30 }
Comparison
AMPL
param inflow {COMMODITIES,NODES};
param inflow (tr):
Pencils Pens :=
Detroit 50 60
Denver 60 40
Boston -50 -40
'New York' -50 -30
Seattle -10 -30 ;

67
Data (cont’d)
gurobipy
cost = {
('Pencils', 'Detroit', 'Boston'): 10,
('Pencils', 'Detroit', 'New York'): 20,
('Pencils', 'Detroit', 'Seattle'): 60,
('Pencils', 'Denver', 'Boston'): 40,
('Pencils', 'Denver', 'New York'): 40,
('Pencils', 'Denver', 'Seattle'): 30,
('Pens', 'Detroit', 'Boston'): 20,
('Pens', 'Detroit', 'New York'): 20,
('Pens', 'Detroit', 'Seattle'): 80,
('Pens', 'Denver', 'Boston'): 60,
('Pens', 'Denver', 'New York'): 70,
('Pens', 'Denver', 'Seattle'): 30 }
Comparison

68
Data (cont’d)
AMPL
param cost {COMMODITIES,ARCS} >= 0;
Comparison
param cost
[Pencils,*,*] (tr) Detroit Denver :=
Boston 10 40
'New York' 20 40
Seattle 60 30
[Pens,*,*] (tr) Detroit Denver :=
Boston 20 60
'New York' 20 70
Seattle 80 30 ;

69
Model
gurobipy
m = Model('netflow')
flow = m.addVars(commodities, arcs, obj=cost, name="flow")
m.addConstrs(
(flow.sum('*',i,j) <= capacity[i,j] for i,j in arcs), "cap")
m.addConstrs(
(flow.sum(h,'*',j) + inflow[h,j] == flow.sum(h,j,'*')
for h in commodities for j in nodes), "node")
Comparison
for i,j in arcs:
m.addConstr(sum(flow[h,i,j] for h in commodities) <= capacity[i,j],
"cap[%s,%s]" % (i,j))
m.addConstrs(
(quicksum(flow[h,i,j] for i,j in arcs.select('*',j)) + inflow[h,j] ==
quicksum(flow[h,j,k] for j,k in arcs.select(j,'*'))
alternatives

70
(Note on Summations)
gurobipy quicksum
m.addConstrs(
(quicksum(flow[h,i,j] for i,j in arcs.select('*',j)) + inflow[h,j] ==
quicksum(flow[h,j,k] for j,k in arcs.select(j,'*'))
Comparison

71
Model (cont’d)
AMPL
var Flow {COMMODITIES,ARCS} >= 0;
minimize TotalCost:
sum {h in COMMODITIES, (i,j) in ARCS} cost[h,i,j] * Flow[h,i,j];
subject to Capacity {(i,j) in ARCS}:
sum {h in COMMODITIES} Flow[h,i,j] <= capacity[i,j];
subject to Conservation {h in COMMODITIES, j in NODES}:
sum {(i,j) in ARCS} Flow[h,i,j] + inflow[h,j] =
sum {(j,i) in ARCS} Flow[h,j,i];
Comparison

72
Solution
gurobipy
m.optimize()
if m.status == GRB.Status.OPTIMAL:
solution = m.getAttr('x', flow)
for h in commodities:
print('nOptimal flows for %s:' % h)
for i,j in arcs:
if solution[h,i,j] > 0:
print('%s -> %s: %g' % (i, j, solution[h,i,j]))
Comparison

73
Solution (cont’d)
AMPL
ampl: solve;
Gurobi 8.0.0: optimal solution; objective 5500
2 simplex iterations
ampl: display Flow;
Flow [Pencils,*,*]
: Boston 'New York' Seattle :=
Denver 0 50 10
Detroit 50 0 0
[Pens,*,*]
: Boston 'New York' Seattle :=
Denver 10 0 30
Detroit 30 30 0
;
Comparison

gurobipy
 Works closely with the Gurobi solver:
callbacks during optimization, fast re-solves after problem changes
 Offers convenient extended expressions:
min/max, and/or, if-then-else
AMPL
 Supports all popular solvers
 Extends to general nonlinear and logic expressions
 Connects to nonlinear function libraries and user-defined functions
 Automatically computes nonlinear function derivatives
74
Integration with Solvers
Comparison

gurobipy
 Everything can be developed in Python
 Extensive data, visualization, deployment tools available
 Limited modeling features also in C++, C#, Java
AMPL
 Modeling language extended with loops, tests, assignments
 Application programming interfaces (APIs) for calling AMPL
from C++, C#, Java, MATLAB, Python, R
 Efficient methods for data interchange
 Add-ons for streamlined deployment
 QuanDec by Cassotis
 Opalytics Cloud Platform
75
Integration with Applications
Comparison

Solver-specific
 Associated with popular commercial solvers
 Executable and declarative alternatives
Solver-independent
 Support multiple solvers and solver types
 Mostly commercial/declarative and free/executable
76
Software Survey

Declarative, commercial
 OPL for CPLEX (IBM)
 MOSEL* for Xpress (FICO)
 OPTMODEL for SAS/OR (SAS)
Executable, commercial
 Concert Technology C++ for CPLEX
 gurobipy for Gurobi
 sasoptpy for SAS Optimization
77
Solver-Specific
Survey

Declarative, commercial
 AIMMS
 AMPL
 GAMS
 MPL
Declarative, free
 CMPL
 GMPL / MathProg
Executable, free
 PuLP; Pyomo / Python
 YALMIP; CVX / MATLAB
 JuMP / Julia
 FLOPC++ / C++
78
Solver-Independent
Survey

Commercial, declarative modeling systems
 Established lineup of solver-independent modeling systems
that represent decades of development and support
 Continuing trend toward integration with
popular programming languages and data science tools
Commercial, executable modeling systems
 Increasingly essential to commercial solver offerings
 Becoming the recommended APIs for solvers
Free, executable modeling systems
 A major current focus
of free optimization software development
 Interesting new executable modeling languages
have become easier to develop than interesting new solvers
79
Trends

Notable cases not detailed earlier . . .
 AIMMS (solver-independent, commercial, declarative)
has extensive application development tools built in
 CMPL (solver-independent, free, declarative)
has an IDE, Python and Java APIs, and remote server support
 GMPL/MathProg (solver-independent, free, declarative)
is a free implementation of mainly a subset of AMPL
 JuMP (solver-independent, free, executable) claims greater
efficiency through use of a new programming language, Julia
 MOSEL for Xpress (solver-specific, commercial)
a hybrid of declarative and executable,
has recently been made free and may accept other solvers
80
Special Notes

81
Balanced Assignment Revisited in AMPL
Sets, parameters, variables (for people)
set PEOPLE; # individuals to be assigned
set CATEG;
param type {PEOPLE,CATEG} symbolic;
# categories by which people are classified;
# type of each person in each category
param numberGrps integer > 0;
param minInGrp integer > 0;
param maxInGrp integer >= minInGrp;
# number of groups; bounds on size of groups
var Assign {i in PEOPLE, j in 1..numberGrps} binary;
# Assign[i,j] is 1 if and only if
# person i is assigned to group j

82
Variables, constraints (for variation)
set TYPES {k in CATEG} := setof {i in PEOPLE} type[i,k];
# all types found in each category
var MinType {k in CATEG, TYPES[k]};
var MaxType {k in CATEG, TYPES[k]};
# fewest and most people of each type, over all groups
subj to MinTypeDefn {j in 1..numberGrps, k in CATEG, l in TYPES[k]}:
MinType[k,l] <= sum {i in PEOPLE: type[i,k] = l} Assign[i,j];
subj to MaxTypeDefn {j in 1..numberGrps, k in CATEG, l in TYPES[k]}:
MaxType[k,l] >= sum {i in PEOPLE: type[i,k] = l} Assign[i,j];
# values of MinTypeDefn and MaxTypeDefn variables
# must be consistent with values of Assign variables
Balanced Assignment

83
Objective, constraints (for assignment)
minimize TotalVariation:
sum {k in CATEG, l in TYPES[k]} (MaxType[k,l] - MinType[k,l]);
# Total variation over all types
subj to AssignAll {i in PEOPLE}:
sum {j in 1..numberGrps} Assign[i,j] = 1;
# Each person must be assigned to one group
subj to GroupSize {j in 1..numberGrps}:
minInGrp <= sum {i in PEOPLE} Assign[i,j] <= maxInGrp;
# Each group must have an acceptable size
𝑔 ∑ 𝑥∈ 𝑔 , for each 𝑗 1, . . . , 𝐺
Balanced Assignment

84
210 people
set PEOPLE :=
BIW AJH FWI IGN KWR KKI HMN SML RSR TBR
KRS CAE MPO CAR PSL BCG DJA AJT JPY HWG
TLR MRL JDS JAE TEN MKA NMA PAS DLD SCG
VAA FTR GCY OGZ SME KKA MMY API ASA JLN
JRT SJO WMS RLN WLB SGA MRE SDN HAN JSG
AMR DHY JMS AGI RHE BLE SMA BAN JAP HER
MES DHE SWS ACI RJY TWD MMA JJR MFR LHS
JAD CWU PMY CAH SJH EGR JMQ GGH MMH JWR
MJR EAZ WAD LVN DHR ABE LSR MBT AJU SAS
JRS RFS TAR DLT HJO SCR CMY GDE MSL CGS
HCN JWS RPR RCR RLS DSF MNA MSR PSY MET
DAN RVY PWS CTS KLN RDN ANV LMN FSM KWN
CWT PMO EJD AJS SBK JWB SNN PST PSZ AWN
DCN RGR CPR NHI HKA VMA DMN KRA CSN HRR
SWR LLR AVI RHA KWY MLE FJL ESO TJY WHF
TBG FEE MTH RMN WFS CEH SOL ASO MDI RGE
LVO ADS CGH RHD MBM MRH RGF PSA TTI HMG
ECA CFS MKN SBM RCG JMA EGL UJT ETN GWZ
MAI DBN HFE PSO APT JMT RJE MRZ MRK XYF
JCO PSN SCS RDL TMN CGY GMR SER RMS JEN
DWO REN DGR DET FJT RJZ MBY RSN REZ BLW ;
Balanced Assignment

85
4 categories, 18 types
set CATEG := dept loc rate title ;
param type:
dept loc rate title :=
BIW NNE Peoria A Assistant
KRS WSW Springfield B Assistant
TLR NNW Peoria B Adjunct
VAA NNW Peoria A Deputy
JRT NNE Springfield A Deputy
AMR SSE Peoria A Deputy
MES NNE Peoria A Consultant
JAD NNE Peoria A Adjunct
MJR NNE Springfield A Assistant
JRS NNE Springfield A Assistant
HCN SSE Peoria A Deputy
DAN NNE Springfield A Adjunct
.......
param numberGrps := 12 ;
param minInGrp := 16 ;
param maxInGrp := 19 ;
Balanced Assignment

86
Model + data = problem instance to be solved (CPLEX)
ampl: model BalAssign.mod;
ampl: data BalAssign.dat;
ampl: option solver cplex;
ampl: solve;
2556 variables:
2520 binary variables
36 linear variables
654 constraints, all linear; 25632 nonzeros
210 equality constraints
432 inequality constraints
12 range constraints
1 linear objective; 36 nonzeros.
CPLEX 12.8.0.0: optimal integer solution; objective 16
59597 MIP simplex iterations
387 branch-and-bound nodes 8.063 sec
Balanced Assignment

87
Model + data = problem instance to be solved (Gurobi)
ampl: option solver gurobi;
ampl: solve;
2556 variables:
36 linear variables
338028 simplex iterations
1751 branch-and-cut nodes 66.344 sec
Balanced Assignment

88
Model + data = problem instance to be solved (Xpress)
ampl: option solver xpress;
ampl: solve;
2556 variables:
36 linear variables
XPRESS 8.4(32.01.08): Global search complete
Best integer solution found 16
6447 branch and bound nodes 61.125 sec
Balanced Assignment

89
Modeling Language Formulation (revised)
Add bounds on variables
var MinType {k in CATEG, t in TYPES[k]}
<= floor (card {i in PEOPLE: type[i,k] = t} / numberGrps);
var MaxType {k in CATEG, t in TYPES[k]
>= ceil (card {i in PEOPLE: type[i,k] = t} / numberGrps);
ampl: include BalAssign+.run
Presolve eliminates 72 constraints.
...
2203 simplex iterations 0.203 sec
Balanced Assignment

Off-the-shelf solvers for broad problem classes
Two main problem classes
 “Linear” solvers
 “Nonlinear” solvers
Other useful classes
 “Constraint” programming solvers
 “Global” optimization solvers
91
Solvers for Model-Based Optimization

Algorithms
 Provisions for integer-valued variables
 Extensions of the technology to related problem classes
 Parallel implementation on multiple processor cores
Support for . . .
 Model-based optimization
 Application deployment
 Cloud-based services
 Optimization on demand
 Server clusters
92
Typical Enhancements
Off-the-Shelf Solvers

93
Benchmarks
Prof. Hans Mittelmann’s benchmark website

94
Benchmarks
By problem type and test set

95
Benchmarks
Documentation, summaries, links to detailed results

Linear objective and constraints
 Continuous variables
 Primal simplex, dual simplex, interior-point
 Integer (including zero-one) variables
 Branch-and-bound + feasibility heuristics + cut generation
 Automatic transformations to integer:
piecewise-linear, discrete variable domains, indicator constraints
 “Callbacks” to permit problem-specific algorithmic extensions
Quadratic extensions
 Convex elliptic objectives and constraints
 Convex conic constraints
 Variable binary in objective
 Transformed to linear (or to convex if binary binary)
96
“Linear” Solvers

CPLEX, Gurobi, Xpress
 Dominant commercial solvers
 Similar features
 Supported by many modeling systems
SAS Optimization, MATLAB intlinprog
 Components of widely used commercial analytics packages
 SAS performance within 2x of the “big three”
MOSEK
 Commercial solver strongest for conic problems
CBC, MIPCL, SCIP
 Fastest noncommercial solvers
 Effective alternatives for easy to moderately difficult problems
 MIPCL within 7x on some benchmarks
97
“Linear” Solvers (cont'd)

Special abilities of certain solvers . . .
 CPLEX has an option to handle nonconvex quadratic objectives
 MOSEK extends to general semidefinite optimization problems
 SCIP extends to certain logical constraints
98
Special Notes
“Linear” Solvers

Continuous variables
 Smooth objective and constraint functions
 Locally optimal solutions
 Variety of methods
 Interior-point, sequential quadratic, reduced gradient
Extension to integer variables
99
“Nonlinear” Solvers

Knitro
 Most extensive commercial nonlinear solver
 Choice of methods; automatic choice of multiple starting points
 Parallel runs and parallel computations within methods
 Continuous and integer variables
CONOPT, LOQO, MINOS, SNOPT
 Highly regarded commercial solvers for continuous variables
 Implement a variety of methods
Bonmin, Ipopt
 Highly regarded free solvers
 Ipopt for continuous problems via interior-point methods
 Bonmin extends to integer variables
100
“Nonlinear” Solvers

Nonlinear + global optimality
 Substantially harder than local optimality
 Smooth nonlinear objective and constraint functions
 Continuous and integer variables
BARON
 Dominant commercial global solver
Couenne
 Highly regarded noncommercial global solver
LGO
 High-quality solutions, may be global
 Objective and constraint functions may be nonsmooth
101
“Global” Solvers

Motivated by “constraint programming”
 Logic directly in constraints using and, or, not operators
 Range of other nonsmooth and logic operators
 “All different” and other special constraints
 Variables in subscripts to other variables and parameter
 Encoding of logic in binary variables not necessary
Alternative solvers employed
 Globally optimal solutions
 Branching search like other “integer” solvers
 Not originally model-based,
but trend has been toward model-based implementations
 More general modeling languages needed
102
“Constraint” Solvers

IBM ILOG CP
 Established commercial constraint programming solver
 Solver-specific modeling language support
 C++ API combining model-based and method-based approaches
 C++ “Concert Technology” executable modeling language
 OPL declarative modeling language
 Some support from solver-independent languages
Gecode, JaCoP
 Notable noncommercial solvers
 Limited modeling language support
103
“Constraint” Solvers

Curious? Try Them Out on NEOS!
104

Solver & Language Listing
NEOS Server
105

Input Page for CPLEX using AMPL
NEOS Server
106

Input Page (cont’d)
NEOS Server
107

Queue Page
NEOS Server
108

Output Page
NEOS Server
109

Output Page (cont’d)
NEOS Server
110

Solvers
 18 categories, 60+ solvers
 Commercial and noncommercial choices
 Almost all of the most popular ones
Inputs
 AMPL, GAMS, and others
 MPS, LP, and other lower-level problem formats
Interfaces
 Web browser
 Special solver (“Kestrel”) for AMPL and GAMS
 Python API
111
About the NEOS Server

Limits
 8 hours
 3 GBytes
Operation
 Requests queued centrally,
distributed to various servers for solving
 650,000+ requests served in the past year,
about 1800 per day or 75 per hour
 17,296 requests on peak day (15 March 2018)
112
About the NEOS Server (cont’d)

Model-Based Optimization / INFORMS International

More Related Content

What's hot (14)

Similar to Model-Based Optimization / INFORMS International (20)

Recently uploaded (20)

Model-Based Optimization / INFORMS International