GAMS An Introduction Hands-on Tutorial on Optimization Frederik - - PowerPoint PPT Presentation

GAMS Development Corp. GAMS Software GmbH www.gams.com

GAMS – An Introduction

Hands-on Tutorial on Optimization Frederik Proske & Lutz Westermann

GAMS Software GmbH

2

Agenda

GAMS at a Glance GAMS – Hands On Examples Outlook

• A Model is a Model is a Model
• Parallelization on HPC Systems
• Deployment of GAMS Models
• …

GAMS at a Glance

4

1976 - A World Bank Slides

The Vision

GAMS came into being!

5

The aim of this system is to provide one representation of a model which is easily understood by both humans and machines.

[J. Bischopp, A. Meeraus, On the Development of a General Algebraic Modeling System in a Strategic Planning Environment. Mathematical Programming Study 20 (1982) 1–29.]

Self-documenting model. A GAMS model is a machine-executable documentation of an

• ptimization problem.

[M. Bussieck & A. Meeraus, Algebraic Modeling for IP and MIP (GAMS), Annals of Operations Research 149(1): History of Integer Programming: Distinguished Personal Notes and Reminiscences, Guest Editors: Kurt Spielberg and Monique Guignard-Spielberg, February, 2007, pp. 49-56 ]

6

What did this give us?

Simplified model development & maintenance Increased productivity tremendously Made mathematical optimization available to a broader audience (domain experts)

➢2012 INFORMS Impact Prize

7

➢Roots: World Bank, 1976 ➢Went commercial in 1987 ➢Locations ➢GAMS Development Corporation (USA) ➢GAMS Software GmbH (Germany) ➢Product

➢The General Algebraic Modeling System

Company

8

Broad User Community and Network 30+ Years

GAMS Development

14,000+ licenses Users: 50% academic, 50% commercial GAMS used in more than 120 countries Uniform interface to ~40 solvers

9

Broad Range of Application Areas

Agricultural Economics Applied General Equilibrium Chemical Engineering Economic Development Econometrics Energy Environmental Economics Engineering Finance Forestry International Trade Logistics Macro Economics Military Management Science/OR Mathematics Micro Economics Physics

10

Foundation of GAMS Powerful algebraic modeling language Open architecture and interfaces to

• ther systems, independent layers

11

Declarative and Procedural Language Elements

Declarative elements

• Similar to mathematical

notation

• Easy to learn - few basic

language elements: sets, parameters, variables, equations, models

• Model is executable

(algebraic) description of the problem

Procedural elements

• Control Flow Statements

(e.g. loops, for, if,…),

• Build complex problem

algorithms within GAMS

• Simplified interaction with
• ther systems
• Data exchange
• APIs

12

Independence of Model and Operating System

Platforms supported by GAMS: Models can be moved between platforms with ease!

13

Cross Platform GUI – GAMS Studio

➢ Open source Qt project (Mac/Linux/Win) ➢ Published on GitHub under GPL ➢ Released in beta status ➢ Group Explorer ➢ Editor / Syntax coloring / Spell checks ➢ Tree view / Syntax-error navigation ➢ Option Editor ➢ Integrated Help ➢ Model Debugging & Profiling ➢ Solver selection & setup ➢ Data viewer ➢ GAMS Processes Control

14

Independence of Model and Solver

All major commercial LP/MIP solver Open Source Solver (COIN) Also solver for NLP, MINLP, global, and stochastic

• ptimization

One environment for a wide range of model types and solvers

Switching between solvers with one line of code!

…

15

Independence of Model and Data

• Declarative Modeling
• ASCII: Initial model development
• GDX: Data layer (“contract”)

between GAMS and applications – Platform independent – No license required – Direct GDX interfaces and general API – … GDX

GAMS SOLVER

csv

16

Independence of Model and User Interface

API’s

• Low Level
• Object Oriented: .Net, Java,

Python, C++

• No modeling capability:

Model is written in GAMS

• Wrapper class that

encapsulates a GAMS model

18

Free Model Libraries ➢ More than 1400 models!

19

• Experience of 30+ years
• Broad user community from different areas
• Lots of model templates
• Strong development interface
• Consistent implementation of design principles
• Simple, but powerful modeling language
• Independent layers
• Open architecture: Designed to interact with other

applications

• Open for new developments
• Protecting investments of users

Why GAMS?

GAMS – Building blocks

21

Sets

• Basic elements of a model
• Syntax:

set[s] set_name ["text"] [/element [text] {,element [text]} /] {,set_name ["text"] [/element [text] {,element [text]} /] } ;

• Elements have up to 63 characters, start letter or digit or are quoted
• Elements have no value (!), that is, ‘1986’ does not have the numerical

value 1986 and ‘01’ ≠ ‘1’

• Text has up to 254 characters, all in one line
• Example:

22

Data

• Data in GAMS consists always of real numbers (no strings)
• Uninitialized data has the default value 0
• 3 forms to declare data:
• Scalar: a single (scalar) number
• Parameter: list oriented data
• Table: table oriented data (at least 2 dimensions)
• Scalar Data:
• Syntax:
• Example:

23

Data: Parameters

• Can be indexed over one or several sets
• Syntax:
• Example:
• Example:

24

Data: Table

• Syntax:
• Example:
• No “free form”: position of elements is of importance
• tables with more than 2 dimensions are also possible

25

Data: Assignments

• Scalar Assignment:
• Indexed Assignment:

26

Data: Expressions (I)

Expression: an arbitrarily complex calculation instruction Arithmetic operators: +, -, *, /, ** (exponentiate)

• 𝑦**𝑜 corresponds to exp(𝑜*ln(𝑦)) -> only allowed for 𝑦 > 0
• power(𝑦,𝑜) can be used instead (if 𝑜 ∊ ℤ)

27

Data: Expressions (II)

Indexed Operations:

28

Variables

Examples:

29

Variable Attributes

Attributes of a variable: Examples:

30

Equations (I)

• Equations serve to define restrictions (constraints) and an objective function

Declaration:

• Syntax:
• Example:

Definition:

• Syntax:

[...] [...]

31

Equations (II)

Example: Attributes of an equation:

32

Model Statements (I)

• Model = collection of equations
• Syntax:
• Example:

33

Model Statements (II)

• Attributes:
• Example:

34

Solving a Model

• Passing a model to a solver and evaluation of results
• Specification of one free variable to be minimized or maximized
• Syntax:
• the model type defines the problem class to be used for the model:
• Example:

[...]

GAMS – Hands On Examples

36

• What does this example show?

A Simple Transportation Problem

• It gives a first glimpse of how a

problem can be formulated in GAMS

• It shows how easy it is to

change model type and, consequently, solver technology

• It shows some basics of data

exchange with GAMS

37

LP

• Determine

minimum transportation cost

• Result: city to city

shipment volumes

MIP

• Discrete

decisions

• E.g.: Ship at

least 100 cases

MINLP

• Non-linearity
• E.g.: Decrease

in unit cost with growing volumes

Scenarios

• SolveLink
• Grid Facility
• GUSS

38

A Simple Transportation Problem

Freight: $90 case / thousand miles

Canning Plants (supply)

Markets (demand) shipments

(Number of cases)

39

Minimize Transportation cost subject to Demand satisfaction at markets Supply constraints

350 San Diego 600 275 300 325 Topeka 1.4 2.5 1.8 1.8 1.7 2.5 Supply

(cases)

Demand

(cases)

Distance

(thousand miles)

New York Chicago Seattle

Freight: $90 case / thousand miles

A Simple Transportation Problem

40

Mathematical Model Formulation

Indices: 𝑗 (Canning plants) 𝑘 (Markets) Decision variables: 𝑦𝑗𝑘 (Number of cases to ship) Data: 𝑑𝑗𝑘 (Transport cost per case) 𝑏𝑗 (Capacity in cases) 𝑐𝑗 (Demand in cases) min 𝑑𝑗𝑘 ∙ 𝑦𝑗𝑘

𝑘 𝑗

(Minimize total transportation cost) subject to 𝑦𝑗𝑘

𝑘

≤ 𝑏𝑗 ∀ 𝑗 (Shipments from each plant ≤ supply capacity) 𝑦𝑗𝑘

𝑗

≥ 𝑐

𝑘 ∀ 𝑘 (Shipments to each market ≥ demand)

𝑦𝑗𝑘 ≥ 0 ∀𝑗, 𝑘 (Do not ship from market to plant) 𝑗, 𝑘 ∈ ℕ

Hands-On

41

GAMS Syntax (LP Model)

42

GAMS Syntax (Data Input)

43

Solution to LP model

Freight: $90 case / thousand miles Total cost: $153,675

50 275 300 275

Canning Plants (supply)

Markets (demand) shipments

(Number of cases)

44

LP

• Determine

minimum transportation cost

• Result: city to city

shipment volumes

MIP

• Discrete

decisions

• E.g.: Ship at

least 100 cases

MINLP

• Non-linearity
• E.g.: Decrease

in unit cost with growing volumes

Scenarios

• SolveLink
• Grid Facility
• GUSS

45

• Shipment volume:

x (continuous variable)

• Discrete decision:

ship (binary variable)

MIP Model: Minimum Shipment of 100 cases

add constraints: 𝑦𝑗,𝑘 ≥ 100 ∙ 𝑡ℎ𝑗𝑞𝑗,𝑘 ∀ 𝑗, 𝑘 (if ship=1, then ship at least 100) 𝑦𝑗,𝑘 ≤ 𝑐𝑗𝑕𝑁 ∙ 𝑡ℎ𝑗𝑞𝑗,𝑘 ∀ 𝑗, 𝑘 (if ship=0, then do not ship at all) 𝑡ℎ𝑗𝑞𝑗,𝑘 ∈ 0,1

100

ship = 0 ship = 1 Cost ($) Not possible x (Number of cases) Hands-On

46

MIP Model: GAMS Syntax

47

MIP Model: Results

48

MIP Model: Solution

Freight: $90 case / thousand miles Total cost: $153,675

325 300 275

Canning Plants (supply)

Markets (demand) shipments

(Number of cases)

49

LP

• Determine

minimum transportation cost

• Result: city to city

shipment volumes

MIP

• Discrete

decisions

• E.g.: Ship at

least 100 cases

MINLP

• Non-linearity
• E.g.: Decrease

in unit cost with growing volumes

Scenarios

• SolveLink
• Grid Facility
• GUSS

50

MINLP: Cost Savings

100

ship = 0 ship = 1 Cost ($) Not possible The cost per case decreases with an increasing shipment volume Replace: min 𝑗 𝑘 𝑑𝑗𝑘 ∙ 𝑦𝑗𝑘 (Minimize total transportation cost) With min 𝑗 𝑘 𝑑𝑗𝑘 ∙ 𝑦𝑗𝑘𝒄𝒇𝒖𝒃 (Minimize total transportation cost) x (Number of cases) Hands-On

51

MINLP Model: GAMS Syntax

52

MINLP Model: Results

53

MINLP Model: Solution

Freight: $90 case / thousand miles

325 300 275

Total cost: $115,438

Canning Plants (supply)

Markets (demand) shipments

(Number of cases)

54

LP

• Determine

minimum transportation cost

• Result: city to city

shipment volumes

MIP

• Discrete

decisions

• E.g.: Ship at

least 100 cases

MINLP

• Non-linearity
• E.g.: Decrease

in unit cost with growing volumes

Scenarios

• SolveLink
• Grid Facility
• GUSS

55

• Solving challenging real-world problems often involves the

solution of many optimization problems

• Decomposition Methods
• Scenario Analysis
• Heuristics
• …
• Such approaches are often chosen, if solving the problem at

hand does not work with a single monolithic model, e.g.

• Due to it’s size and the required resources (e.g. memory)
• Due to time restrictions (Problem should be solved in minutes

but it takes days)

• …

→GAMS Grid Facility →Gather-Update-Solve-Scatter

Motivation

56

Controls GAMS function when linking to solver. Model transport /all/ ; transport.solveLink={0 %Solvelink.ChainScript%, 1 %Solvelink.CallScript%, 2 %Solvelink.CallModule%, 3 %Solvelink.AsyncGrid%, 4 %Solvelink.AsyncSimulate%, 5 %Solvelink.LoadLibrary%, 6 %solveLink.aSyncThreads%, 7 %solveLink.threadsSimulate%}; solve transport using lp minimizing z;

SolveLink Option

57

• ChainScript [0]: Solver process, GAMS vacates memory

+ Maximum memory available to solver + protection against solver failure (hostile link)

• swap to disk
• Call{Script [1]/Module [2]}: Solver process, GAMS stays live

+ protection against solver failure (hostile link) + no swap of GAMS database

• file based model communication
• LoadLibrary [5]: Solver DLL in GAMS process

+ fast memory based model communication + update of model object inside the solver (hot start)

• not supported by all solvers

SolveLink Option – Sequential Solves

58

• Generate 100 distance scenarios with random data
• Solve these scenarios with the solveLink values…
• ChainScript

[0]

• CallModule

[2]

• LoadLibrary

[5]

• Compare the execution time of solving all scenarios with

different solveLink settings

• Hint: Look at the GAMS function jNow

SolveLink Option Sequential – Exercise

Hands-On

59

SolveLink Option – Sequential Solves

• 88 PARAMETER time time for 100 scenarios

ChainScript 6.710, CallModule 2.694, LoadLibrary 0.578

60

• aSyncGrid [3]: GAMS starts the solution and continues in a

Grid computing environment

• aSyncThreads [6]: The problem is passed to the solver in

core without use of temporary files, GAMS does not wait for the solver to come back

SolveLink Option – Asynchronous Solves

61

• Generate 100 distance scenarios with random data
• Solve these scenarios with the solveLink values…
• aSyncGrid

[3]

• aSyncThreads

[6]

• Compare the execution time of solving all scenarios with

different solveLink settings

• Hint: Check the log for output about solveLink
• → Use solver CplexD instead of Cplex
• Hint: Look at the following GAMS functions:
• readyCollect
• handleCollect
• handleDelete

SolveLink Option Asynchronous – Exercise

Hands-On

62

SolveLink Option – Asynchronous Solves

• 96 PARAMETER time time for 100 scenarios

aSyncGrid 4.259, aSyncThreads 0.496

ChainScript 6.710 CallModule 2.694 LoadLibrary 0.578 aSyncGrid 4.259 aSyncThreads 0.496

63

• Helpful, if large ratio of solver time / GAMS time

SolveLink Option – Asynchronous Solves

ChainScript 29.807 CallModule 30.004 LoadLibrary 28.864 aSyncGrid 9.112 aSyncThreads 7.901

64

GUSS – Gather-Update-Solve-Scatter

aka Scenario Solver

Generation Solution Update Simple Serial Solve Loop Scenario Solver/GUSS Generates model once and updates the algebraic model keeping the model “hot” inside the solver. Loop Generation Solution Update

65

GUSS – Gather-Update-Solve-Scatter

aka Scenario Solver

ChainScript 6.710 CallModule 2.694 LoadLibrary 0.578 aSyncGrid 4.259 aSyncThreads 0.496 GUSS 0.273

66

• trnsgrid: https://www.gams.com/latest/gamslib_ml/libhtml/gamslib_trnsgrid.html
• Simple asynchronous solves in a loop, separate collection

loop

• tgridmix: https://www.gams.com/latest/gamslib_ml/libhtml/gamslib_tgridmix.html
• Asynchronous solves in combined submission & collection
• loop. Keep number of submitted models <= #threads
• gussgrid: https://www.gams.com/latest/gamslib_ml/libhtml/gamslib_gussgrid.html
• Asynchronous GUSS-solves in combined submission &

collection loop. Keep number of submitted models <=

#threads

Grid & GUSS – Examples from the model library

A Model is a Model is a Model*

* Freely adapted from the poetry of Gertrude Stein, 1874-1946, American writer

68

What is a Model?

69

• A mathematical model is a description of a system using

mathematical language (from: Wikipedia) ➔ Mathematical Programming (MP) Model: List of Equations

What is a Model?

70

• A mathematical model is a description of a system using

mathematical language (from: Wikipedia) ➔ Mathematical Programming (MP) Model: List of Equations

• Collection of several intertwined MP Models
• Data Preparation
• Data Calibration
• “Solution” Module (e.g. sequential, parallel loop)
• Report Module

What is a Model in GAMS?

71

• Defining scope of a (part of a)

project/model

• IT, analysts, managers, model builders

have different views

• Misunderstandings common with verbal

descriptions

• Use a model to define the scope
• Requirements for such a model
• Rapid prototyping (max. 1-2 man days)
• Standard IO interface (Excel)
• Remote execution (e.g. through Web UI)

Model as Communication Vehicle

72

• Optimization models do not allow for any

type of vagueness

• Input data requirements
• Objectives and constraints
• Results
• Misunderstandings result in failure of the

model

• Compilation/execution errors
• Infeasible/unbounded MP models
• Model as a contract

Model as Analytic Framework

73

• Good models do not rely on contract

(input data)

• Input Module (handles bad data)
• Simple error checks
• Analyzing and reporting complex data

problems

• Good models (modeling systems) provide

access to results via independent result analyzers for non model experts

• Analytic framework help define result

metric

• e.g. violations of soft constraints

Model as Contract

74

Model as Cost Saver

• Most convincing and obvious reason for using an
• ptimization model
• Science of better (INFORMS)
• Often exaggerated/difficult to estimate

Model Roles over Time

Communication Vehicle Analytic Framework Contract Cost Saver

Outlook: Parallelization

• n HPC Systems

From simple sequential to highly parallel solve statements

76

Off-the-shelf software (speedup via parallelization)

How does GAMS support problem specific solution approaches that are well suited/customized for HPC?

Optimization Problem core core core core memory Multi-core shared memory Distributed (shared) memory

. . .

core core core core memory

Node 0

core core core core memory

Node 1

core core core core memory

Node n-1

Available Computing Resources standard HPC

77

Non-zero Plot of matrix Solve sequence of problems (e.g. in Benders Decomp.) … … … Parallelize … … … …

time time

… … Decompose Use structure exploiting solver User Annotation to define block structure 1 2 GAMS supports different levels of parallelization GAMS provides annotation facilities and HPC solver links Optimization Problem

78

• loop body code in sequence, often with an

expensive solve statement:

Sequential Solve Statements in Loops

Model generation Solution process … Model generation Solution process Model generation Solution process

time

79

• SolveLink option specifies the solver linking

conventions

• Split loop in submission & collection loop:
• Model generation and loop body code in sequence
• Either file based IO or limited to shared memory

Parallel Solves – GAMS Grid Facility

MG S MG S MG S

time

80

mpiexec –n 5 gams myfile

Excursus 1: Message Passing Interface (MPI)

gams myfile gams myfile gams myfile gams myfile gams myfile

81

broadcast(db,0) mpiexec –n 5 gams myfile

Excursus 1: Message Passing Interface (MPI)

gams myfile <-- %sysenv.PMI_RANK%=0 gams myfile <-- %sysenv.PMI_RANK%=1 gams myfile <-- %sysenv.PMI_RANK%=2 gams myfile <-- %sysenv.PMI_RANK%=3 gams myfile <-- %sysenv.PMI_RANK%=4 1 2 3 4 gather(db,0) 1 2 3 4 myfile.gms – pseudo code

82

mpiexec –n 5 gams myfile

Excursus 1: Message Passing Interface (MPI)

gams myfile <-- %sysenv.PMI_RANK%=0 gams myfile <-- %sysenv.PMI_RANK%=1 gams myfile <-- %sysenv.PMI_RANK%=2 gams myfile <-- %sysenv.PMI_RANK%=3 gams myfile <-- %sysenv.PMI_RANK%=4 myfile.gms – pseudo code MG S … MG S MG S

time

83

mpiexec –n 5 gams myfile

Excursus 1: Message Passing Interface (MPI)

gams myfile <-- %sysenv.PMI_RANK%=0 gams myfile <-- %sysenv.PMI_RANK%=1 gams myfile <-- %sysenv.PMI_RANK%=2 gams myfile <-- %sysenv.PMI_RANK%=3 gams myfile <-- %sysenv.PMI_RANK%=4

• Requires reorganization of the

code but allows parallel solve

• Distribute/merging data easy

(part of MPI)

• Network based communication
• Need to make GAMS aware of

MPI → Embedded Code

myfile.gms – pseudo code

84

Excursus 2: Embedded Code Facility

85

set scen 'scenario set' / scen1*scen100 / s(scen) 'dynamic secenario subset' k 'benders iterations' / k1*k1000 /; ... // preparatory work loop(k$( NOT done ), ... // setup model for master-problem solve master min obj_master use lp; ... // fix first stage variables loop(scen, ... // setup model for sub-problem

• ption clear=s; s(scen) = yes;

solve sub min obj_sub use lp; ... // process results ); ... // compute cuts for next master ... // free fixed first stage variables ... // set done=1 if convergence criterion is met ); ... // reporting

Example: Sequential Benders Decomposition

86

set scen 'scenario set' / scen1*scen100 / s(scen) 'dynamic secenario subset' k 'benders iterations' / k1*k1000 /; ... embeddedCode Python: from mpi4py import * comm = MPI.COMM_WORLD ... pauseEmbeddedCode ... // preparatory work $ifthen.MPI 0==%sysenv.PMI_RANK% loop(k$( NOT done ), ... // setup model for master-problem solve master min obj_master use lp; ... // fix first stage variables continueEmbeddedCode: comm.bcast([[done]] + <data for sub>, root=0) cut = comm.gather(None, root=0)[1:] ... // gathered data → GAMS data struct. pauseEmbeddedCode <load GAMS data struct.> ... // compute cuts ... // free fixed first stage variables ... // set done=1 if convergence criterion is met ); continueEmbeddedCode: comm.bcast([[done],<empty>], root=0) endEmbeddedCode ... // reporting $else.MPI

Example: Parallel Benders with mpi4py

set scen 'scenario set' / scen1*scen100 / s(scen) 'dynamic secenario subset' k 'benders iterations' / k1*k1000 /; ... embeddedCode Python: from mpi4py import * comm = MPI.COMM_WORLD ... pauseEmbeddedCode ... // preparatory work $else.MPI s(scen) = ord(scen)=%sysenv.PMI_RANK%; while(1, continueEmbeddedCode: primal_solution = comm.bcast(None, root=0) // broadcasted data → GAMS data struct. pauseEmbeddedCode <GAMS data struct.> abort.noerror$done 'terminating subprocess'; solve sub min obj_sub use lp; ... // process results continueEmbeddedCode: comm.gather(<subproblem results>), root=0 ) pauseEmbeddedCode ); $endif.MPI

PMI_RANK=0 PMI_RANK>=1

87

• Two-stage stochastic problem emerged from energy system model
• 100 scenarios
• Deterministic Equivalent:

21,029,101 rows, 23,217,077 columns, 85,721,477 non-zeroes

• Benders:
• Master: up to 553 rows, 177 columns, 24,911 non-zeroes
• Sub: 210,282 rows 232,161 columns 696,461 non-zeroes
• 19 lines of Python Code + some refactorization of GAMS code for MPI version

All runs were made with GAMS 25.1.2 on JURECA@JSC with 24 cores per node, 2.5 GHz, (Intel Xeon E5-2680 v3 Haswell), 128 GB RAM 1: single node, 16 cores, CPLEX barrier, no crossover 2: single node, 4 cores per solve statement, CPLEX barrier, advind 0 3: 17 nodes, 404 cores in total, 4 cores per solve statement, CPLEX barrier, advind 0

Computational Result(s)

TIME [sec] Method sub- problems master- problem total Deterministic Equivalent1 4059.00

• Seq. Benders2

2394.92 0.18 2395.10 MPI Benders3 28.35 0.16 28.51

Deployment of GAMS models

89

Calling GAMS from your Application

Creating Input for GAMS Model → Data handling using GDX API Callout to GAMS →GAMS option settings using Option API →Starting GAMS using GAMS API Reading Solution from GAMS Model → Data handling using GDX API

Application

GDX

GAMS SOLVER

90

• Low level APIs
• GDX, OPT, GAMSX, GMO, …
• High performance and flexibility
• Automatically generated imperative APIs for

several languages (C, C++, C#, Delphi, Java, Python, VBA, …)

• Object Oriented GAMS API
• Additional layer on top of the low level APIs
• Object Oriented
• Written by hand to meet the specific

requirements of different Object Oriented languages

Low level APIs → Object Oriented API

91

• GAMS comes with several OO APIs (Python, Java, C++, C#, …) to

develop applications → Programming required to build your applications

92

From GAMS Model to Visual Web User Interface

93

1

Basic setup: ✓ Annotating GAMS model (defining the input and output data to be displayed in the WebUI)

From GAMS Model to Visual Web User Interface

94

✓

Fully functional interface by only specifying input and output data

✓

Tabular view of input (editable) and output data

✓

Graphical visualization via pivot charts

Basic Setup – GAMS Model Annotations

95

Basic Setup – GAMS Model Annotations

96

Basic Setup – GAMS Model Annotations

97

Basic Setup – GAMS Model Annotations

98

1 2

Basic setup: ✓ Annotating GAMS model (defining the input and output data to be displayed in the WebUI) Advanced setup: ✓ Configuration of standard graphics and UI ✓ Sophisticated (custom) graphics (R API) ✓ Scenario management with internal database

From GAMS Model to Visual Web User Interface

99

Advanced Setup – Configuration

✓

Configuration via JSON file

✓

Access to a number of pre- implemented tools for graphical representation

✓

Focus on configuration, not programming

100

Advanced Setup – Sophisticated graphics

✓

Sophisticated graphics created in R can be included as modules

✓

Access to the entire R ecosystem

✓

Easily extendable with the wide spectrum of the R programming language

101

1 2 3

Advanced setup: ✓ Configuration of standard graphics and UI ✓ Sophisticated (custom) graphics (R API) ✓ Scenario management with internal database Enterprise setup: ✓ User- and Application management Initialization: ✓ Annotating GAMS model (defining the input and output data to be displayed in the WebUI)

From GAMS Model to Visual Web User Interface

102

Enterprise Setup – User and Application Management

✓

Local or server-based solution

✓

User authentication (e.g. LDAP, OAuth 2.0, Google, GitHub, Facebook)

✓

Multi-Application support with docker-based technology

Yaml config file

103

Enhanced Model Deployment in GAMS using R/Shiny

• Application connects Web User Interface with a GAMS

model

• User Interface allows

✓ Data exchange via local files or database ✓ Modification of the input data ✓ Extensive visualization options ✓ Comparison of different scenarios ✓ Multi-user support based on Docker technology ✓ User authentication

• Tool with intuitive interface for planners

(configuration vs. programming)

• This “product” is currently under development. If you are

interested in getting involved, please contact support@gams.com

104

Welcome to Jupyter @ GAMS!

105

GAMS Jupyter Example

Hands-On

106

• Runs in a browser/on a server

→ No local installation needed

• Allows to use notebook technology in combination with

GAMS

• Notebooks allow to combine GAMS and Python
• GAMS works great with well structured data and optimization

models

• Python is very rich in features to retrieve, manipulate, and

visualize data that comes in all sort of ways

• ➔ Combining GAMS and Python in a notebook makes is easy

to tell optimization story with text, data, graphs, math, and models

• This “product” is currently under development.

Give it a try at https://jupyterhub.gams.com/hub/login

Using GAMS Jupyter Notebooks to tell “optimization stories”

Outlook: Stochastic Programming

108

Stochastic Programming in GAMS

EMP Information

(uncertain Par.)

Reformulated Model Solution

Mapping Solution into original space

Deterministic Model

Translation

Solve with established Algorithms

EMP/SP ➢ Simple interface to add uncertainty to existing deterministic models ➢ (EMP) Keywords to describe uncertainty include: discrete and parametric random variables, stages, chance constraints, Value at Risk, ... ➢ Available solution methods: ➢ Automatic generation of Deterministic Equivalent (can be solved with any solver) ➢ Specialized commercial algorithms (DECIS, LINDO)

109

Transport Example – Uncertain Demand

bf Prob: 0.3 Val: 0.90 Prob: 0.5 Val: 1.00 Prob: 0.2 Val: 1.10

Decisions to make

➢ First-stage decision: How many units should be shipped “here and now” (without knowing the outcome) ➢ Second-stage (recourse) decision: ➢ How can the model react if we do not ship enough? ➢ Penalties for “bad” first-stage decisions, e.g. buy additional cases u(j) at the demand location:

costsp .. z =e= sum((i,j), c(i,j)*x(i,j))+ sum(j,0.3*u(j)); demandsp(j) .. sum(i, x(i,j)) =g= bf*b(j) - u(j) ;

Uncertain demand factor bf

110

Uncertain Demand: GAMS Algebra

111

Uncertain Demand: Results

112

• The Extended Mathematical Programming (EMP)

framework is used to replace parameters in the model by random variables

• Support for Multi-stage recourse problems and chance

constraint models

• Easy to add uncertainty to existing deterministic models, to

either use specialized algorithms or create Deterministic Equivalent (new free solver DE)

• More information:

https://www.gams.com/latest/docs/UG_EMP_SP.html

Stochastic Programming in GAMS