Casadi Opti stack: to_function() with parameter for set_inital() method does not work

[martgromag]

Hello,

my intention is to define an optimization problem with CasADi Opti() and finally create a function out of it (with opti.to_function() method) similar like that (see, the set_inital() is set to constant 10. hardcoded) :

opti = ca.Opti()
x=opti.variable(1)
init_value = opti.parameter(1) # not used here
opti.minimize((x-1)**2+1)
opti.subject_to(x>0)

opti.solver("ipopt")
opti.set_initial(x,10.) # hardcoded inital value

my_function = opti.to_function('my_function',[init_value],[x],['init_value'],['x'])
x_sol=my_function(1)
print(x_sol)

now I want to make the initalization accessible at the function interface such, that each time I call the function (iteratively, e.g. in a model predictive control manner) I can define the inital state --> intention is to do a warm start with a good guess solution!

# formulate optimization problem & to_function with parameter as initial value
opti = ca.Opti()
x=opti.variable(1)
init_value = opti.parameter(1) # now the intention is to use this parameter
opti.minimize((x-1)**2+1)
opti.subject_to(x>0)

opti.solver("ipopt")
opti.set_initial(x,init_value) # set parameter as inital value --> init value should be set by function interface

my_function = opti.to_function('my_function',[init_value],[x],['init_value'],['x'])
x_sol=my_function(10.) # set inital value to 10.
print(x_sol)

BUT, in this case I get following error message:

---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
[~\AppData\Local\Temp\ipykernel_17640\3141554485.py](https://file+.vscode-resource.vscode-cdn.net/c%3A/Projects/github/mi_ptceu_pcpc/~/AppData/Local/Temp/ipykernel_17640/3141554485.py) in ?()
----> 9 # formulate optimization problem & to_function with parameter as initial value
     10 opti = ca.Opti()
     11 x=opti.variable(1)
     12 init_value = opti.parameter(1) # now the intention is to use this parameter

[c:\Projects\github\mi_ptceu_pcpc\.venv\lib\site-packages\casadi\casadi.py](file:///C:/Projects/github/mi_ptceu_pcpc/.venv/lib/site-packages/casadi/casadi.py) in ?(self, *args)
  47676 
  47677 
  47678 
  47679         """
> 47680         return _casadi.Opti_set_initial(self, *args)

NotImplementedError: Wrong number or type of arguments for overloaded function 'Opti_set_initial'.
  Possible prototypes are:
    set_initial(self,[MX])
    set_initial(self,MX,DM)
  You have: '(Opti,MX,MX)'

Any suggestions/hints what I am doing wrong? Or how I can achieve my goal to be able to provide a inital state to the solver via function interface?
Or is there a better way to do this (warmstart) for MPC application?

kind regards,
Martin

[brunoml5]

Hi!

The command opti.set_initial(x, init_value) requires a number for the second variable, it cannot be a symbolic.

I don't know if you can do exactly what you want with opti. One option is the following:

opti = ca.Opti()

x = opti.variable(1)
opti.minimize((x-1)**2 + 1)
opti.subject_to(x > 0)

opti.solver("ipopt")
opti.set_initial(x, 1)

sol1 = opti.solve()
print(sol1.value(x))

opti.set_initial(x, 10)     # New initial value

sol2 = opti.solve()
print(sol2.value(x))

Or you can follow the documentation and use the following functions:

sol1 = opti.solve()
print(sol1.value(x))

# Compact way of warm-starting the primal and dual variables
opti.set_initial(sol1.value_variables())
opti.set_initial(opti.lam_g, sol1.value(opti.lam_g))

sol2 = opti.solve()
print(sol2.value(x))

Another option is to use the low level interface for defining of the NLP and then wraping it in a Function. What I do is the following:

import casadi as ca

# Start with an empty NLP
w, w0, lbw, ubw, g, lbg, ubg = [], [], [], [], [], [], []

x = ca.MX.sym('x', 1)
w.append(x)
w0.append(1)            # Initial value for x
lbw.append(-ca.inf)
ubw.append(ca.inf)

f = (x - 1)**2 + 1  # objective

g.append(x)         # constraint
lbg.append(0)
ubg.append(ca.inf)

w = ca.vertcat(*w)  # Concatenate the input variable for the solver

nlp = {'x': w, 'f': f, 'g': ca.vertcat(*g), 'p': []}
opts = {}   # Solver options

solver = ca.nlpsol("solver", 'ipopt', nlp, opts)

# Call the solver with symbolic w
sol = solver(x0=w, p=[], lbx=lbw, ubx=ubw, lbg=lbg, ubg=ubg)

# Wrap everything in a Casadi Function
fun_solver = ca.Function('fun_solver',
                         [w], [sol['x'], sol['f']],
                         ['x0'], ['x', 'f'])

out_x, out_f = fun_solver(1)    # Initial value for x
out_x, out_f = fun_solver(10)    # Different initial value for x

Make sure you print solver, sol and fun_solver so that you understand what is happening. The result is quite neat.

[brunoml5]

You can also use the Casadi Function to wrap your solver in a more elegant way.

For instance, imagine that you want the state and input variables "x" and "u" in the whole horizon in matrix form for your MPC. But they are mixed in "w" which must be a vector. Then, you can do the following:

X = ca.MX.sym('x', nx, 10)  # Matrix for states on the horizon
U = ca.MX.sym('x', nu, 10)  # Matrix for inputs on the horizon

w = []
w.append(ca.vec(X))
w.append(ca.vec(U))
w = ca.vertcat(*w)

### Define your optimization problem
# ...
###

# Call your solver
sol = solver(x0=w0, p=[], lbx=lbw, ubx=ubw, lbg=lbg, ubg=ubg)

# Function to map between w and the matrices X and U
from_w = ca.Function('from_w',
                     [w], [X, U],
                     ['w'], ['X', 'U'])

# Then, call "from_w" with the result "sol" to retrieve X and U in matrix form
out_X, out_U = from_w(sol['x'])

You can do all kind of cool stuff this this, even wrap your solver and calculate derivatives for it!

I hope it helps!

[martgromag]

Thank you a lot for the valuable answers (and sorry for my late reply)!