solvers/callback.py

This example demonstrates how to use callback function for Ipopt.

View output (PDF) | source (python)

See also

casadi::Function();

 



 
from casadi import *
from numpy import *
 




 
x=SX.sym("x")
y=SX.sym("y")
 
f = (1-x)**2+100*(y-x**2)**2
nlp={'x':vertcat(x,y), 'f':f,'g':x+y}
fcn = Function('f', [x, y], [f])
 
import matplotlib
if "Agg" not in matplotlib.get_backend():
  matplotlib.interactive(True)
 
from pylab import figure, subplot, contourf, colorbar, draw, show, plot, title
 
import time
 
class MyCallback(Callback):
  def __init__(self, name, nx, ng, np, opts={}):
    Callback.__init__(self)
 
    self.nx = nx
    self.ng = ng
    self.np = np
 
    figure(1)
 
    x_,y_ = mgrid[-1:1.5:0.01,-1:1.5:0.01]
    z_ = DM.zeros(x_.shape)
 
    for i in range(x_.shape[0]):
      for j in range(x_.shape[1]):
        z_[i,j] = fcn(x_[i,j],y_[i,j])
    contourf(x_,y_,z_)
    colorbar()
    title('Iterations of Rosenbrock')
    draw()
 
    self.x_sols = []
    self.y_sols = []
 
    
    self.construct(name, opts)
 
  def get_n_in(self): return nlpsol_n_out()
  def get_n_out(self): return 1
  def get_name_in(self, i): return nlpsol_out(i)
  def get_name_out(self, i): return "ret"
 
  def get_sparsity_in(self, i):
    n = nlpsol_out(i)
    if n=='f':
      return Sparsity. scalar()
    elif n in ('x', 'lam_x'):
      return Sparsity.dense(self.nx)
    elif n in ('g', 'lam_g'):
      return Sparsity.dense(self.ng)
    else:
      return Sparsity(0,0)
  def eval(self, arg):
    
    darg = {}
    for (i,s) in enumerate(nlpsol_out()): darg[s] = arg[i]
 
    sol = darg['x']
    self.x_sols.append(float(sol[0]))
    self.y_sols.append(float(sol[1]))
 
    if hasattr(self,'lines'):
      if "template" not in matplotlib.get_backend(): 
        self.lines[0].set_data(self.x_sols,self.y_sols)
 
    else:
      self.lines = plot(self.x_sols,self.y_sols,'or-')
 
    draw()
    time.sleep(0.25)
 
    return [0]
 
mycallback = MyCallback('mycallback', 2, 1, 0)
opts = {}
opts['iteration_callback'] = mycallback
opts['ipopt.tol'] = 1e-8
opts['ipopt.max_iter'] = 50
solver = nlpsol('solver', 'ipopt', nlp, opts)
sol = solver(lbx=-10, ubx=10, lbg=-10, ubg=10)
 

 
matplotlib.interactive(False)
show()