GEKKO Python is designed for large-scale optimization and accesses solvers of constrained, unconstrained, continuous, and discrete problems. Problems in linear programming, quadratic programming, integer programming, nonlinear optimization, systems of dynamic nonlinear equations, and multi-objective optimization can be solved. The platform can find optimal solutions, perform tradeoff analyses, balance multiple design alternatives, and incorporate optimization methods into external modeling and analysis software. It is free for academic and commercial use under the MIT license.
The GEKKO package is available through the package manager pip in Python.
pip install gekko
Another method to obtain GEKKO is to include the following code snippet at the beginning of a Python script. If GEKKO is not available, it uses the pip module to install it.
try: from pip import main as pipmain except: from pip._internal import main as pipmain
pipmain(['install','gekko']) # to upgrade: pipmain(['install','--upgrade','gekko'])
The latest GEKKO source is available on GitHub. Download statistics are available from the PyPI Stats Website. Functionality is tested with Python 2.7 and Python 3+ for all operating systems (Windows, MacOS, Linux) and architectures (such as ARM processors) that support Python.
If you use GEKKO and publish the results, please consider citing the following article:
Beal, L.D.R., Hill, D., Martin, R.A., and Hedengren, J. D., GEKKO Optimization Suite, Processes, Volume 6, Number 8, 2018, doi: 10.3390/pr6080106. Article - BibTeX - RIS
There are 18 example problems with GEKKO that are provided below. These examples demonstrate the equation solving, regression, differential equation simulation, nonlinear programming, machine learning, model predictive control, moving horizon estimation, debugging, and other applications. While these applications are designed to be tutorial in nature and very simple, GEKKO references are further application examples of complex and multi-disciplinary systems.
from gekko import GEKKO
m = GEKKO()# create GEKKO model
y = m.Var(value=2)# define new variable, initial value=2
m.Equation(y**2==1)# define new equation
m.options.SOLVER=1# change solver (1=APOPT,3=IPOPT)
m.solve(disp=False) print('y: ' + str(y.value))# print variable value
from gekko import GEKKO
m = GEKKO()# create GEKKO model
x = m.Var()# define new variable, default=0
y = m.Var()# define new variable, default=0
m.Equations([3*x+2*y==1, x+2*y==0])# equations
m.solve(disp=False)# solve print(x.value,y.value)# print solution
from gekko import GEKKO import numpy as np import matplotlib.pyplotas plt
xm = np.array([0,1,2,3,4,5])
ym = np.array([0.1,0.2,0.3,0.5,0.8,2.0])
#### Solution
m = GEKKO()
m.options.IMODE=2 # coefficients
c =[m.FV(value=0)for i inrange(4)]
x = m.Param(value=xm)
y = m.CV(value=ym)
y.FSTATUS=1 # polynomial model
m.Equation(y==c[0]+c[1]*x+c[2]*x**2+c[3]*x**3)
# linear regression
c[0].STATUS=1
c[1].STATUS=1
m.solve(disp=False)
p1 =[c[1].value[0],c[0].value[0]]
# Fit parameter weights
m = train
m.inpt.value=x
m.outpt.value=y
m.outpt.FSTATUS=1 for i inrange(len(m.w1)):
m.w1[i].FSTATUS=1
m.w1[i].STATUS=1
m.w1[i].MEAS=1.0 for i inrange(len(m.w2a)):
m.w2a[i].STATUS=1
m.w2b[i].STATUS=1
m.w2a[i].FSTATUS=1
m.w2b[i].FSTATUS=1
m.w2a[i].MEAS=1.0
m.w2b[i].MEAS=0.5 for i inrange(len(m.w3)):
m.w3[i].FSTATUS=1
m.w3[i].STATUS=1
m.w3[i].MEAS=1.0
m.options.IMODE=2
m.options.SOLVER=3
m.options.EV_TYPE=2
m.solve(disp=False)
# Test sample points
m =test for i inrange(len(m.w1)):
m.w1[i].MEAS=train.w1[i].NEWVAL
m.w1[i].FSTATUS=1 print('w1['+str(i)+']: '+str(m.w1[i].MEAS)) for i inrange(len(m.w2a)):
m.w2a[i].MEAS=train.w2a[i].NEWVAL
m.w2b[i].MEAS=train.w2b[i].NEWVAL
m.w2a[i].FSTATUS=1
m.w2b[i].FSTATUS=1 print('w2a['+str(i)+']: '+str(m.w2a[i].MEAS)) print('w2b['+str(i)+']: '+str(m.w2b[i].MEAS)) for i inrange(len(m.w3)):
m.w3[i].MEAS=train.w3[i].NEWVAL
m.w3[i].FSTATUS=1 print('w3['+str(i)+']: '+str(m.w3[i].MEAS))
m.inpt.value=np.linspace(-2*np.pi,4*np.pi,100)
m.options.IMODE=2
m.options.SOLVER=3
m.solve(disp=False)
from gekko import GEKKO import numpy as np import matplotlib.pyplotas plt
m = GEKKO()# initialize gekko
nt =101
m.time= np.linspace(0,2,nt) # Variables
x1 = m.Var(value=1)
x2 = m.Var(value=0)
u = m.Var(value=0,lb=-1,ub=1)
p = np.zeros(nt)# mark final time point
p[-1]=1.0
final = m.Param(value=p) # Equations
m.Equation(x1.dt()==u)
m.Equation(x2.dt()==0.5*x1**2)
m.Obj(x2*final)# Objective function
m.options.IMODE=6# optimal control mode
m.solve(disp=False)# solve
plt.figure(1)# plot results
plt.plot(m.time,x1.value,'k-',label=r'$x_1$')
plt.plot(m.time,x2.value,'b-',label=r'$x_2$')
plt.plot(m.time,u.value,'r--',label=r'$u$')
plt.legend(loc='best')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
# Controller model
Kc =15.0# controller gain
tauI =2.0# controller reset time
tauD =1.0# derivative constant
OP_0 = m.Const(value=0.0)# OP bias
OP = m.Var(value=0.0)# controller output
PV = m.Var(value=0.0)# process variable
SP = m.Param(value=step)# set point
Intgl = m.Var(value=0.0)# integral of the error
err = m.Intermediate(SP-PV)# set point error
m.Equation(Intgl.dt()==err)# integral of the error
m.Equation(OP == OP_0 + Kc*err + (Kc/tauI)*Intgl - PV.dt())
# Process model
Kp =0.5# process gain
tauP =10.0# process time constant
m.Equation(tauP*PV.dt() + PV == Kp*OP)
from gekko import GEKKO import numpy as np import matplotlib.pyplotas plt
m = GEKKO()
m.time= np.linspace(0,20,41)
# Parameters
mass =500
b = m.Param(value=50)
K = m.Param(value=0.8)
# Manipulated variable
p = m.MV(value=0, lb=0, ub=100)
p.STATUS=1# allow optimizer to change
p.DCOST=0.1# smooth out gas pedal movement
p.DMAX=20# slow down change of gas pedal
# Controlled Variable
v = m.CV(value=0)
v.STATUS=1# add the SP to the objective
m.options.CV_TYPE=2# squared error
v.SP=40# set point
v.TR_INIT=1# set point trajectory
v.TAU=5# time constant of trajectory
# Process model
m.Equation(mass*v.dt()== -v*b + K*b*p)
m.options.IMODE=6# control
m.solve(disp=False)
# get additional solution information import json withopen(m.path+'//results.json')as f:
results = json.load(f)
print('--------- Follow local path to view files --------------') print(m.path)# show source file path
m.open_folder() print('--------------------------------------------------------')
# test application
u = m.FV(value=5,name='u')# define fixed value
x = m.SV(name='state')# define state variable
m.Equation(x==u)# define equation
m.options.COLDSTART=1# coldstart option
m.options.DIAGLEVEL=0# diagnostic level (0-10)
m.options.MAX_ITER=500# adjust maximum iterations
m.options.SENSITIVITY=1# sensitivity analysis
m.options.SOLVER=1# change solver (1=APOPT,3=IPOPT)
m.solve(disp=True) print('x: ' + str(x.value))# print variable value
There are many other applications and instructional material posted to this freely available course web-site. The online course is generally offered starting each year in January. There are two course projects that include the advanced temperature control lab (1st project) and a project that is a group choice (2nd project). Below is an example student presentation at the end of the course. It is representative of the modeling, estimation, and control methods that are taught in the dynamic optimization course.
