Running optimizations with maps as input

[TorkelE]

In MTK and various SciML packages commonly to have e.g. parameter sets on the form of maps, e.g.:

using ModelongToolkit
@parameters p1 p2
x0 = [p1 => 0.0, p2 => 0.0]

Many of these packages also use SciML/Optimization to e.g. find optimal parameter sets. It would be useful if SciML/Optimization could accept these objects in their runs, e.g.

using ModelongToolkit, Optimization, OptimizationOptimJL
@parameters p1 p2
rosenbrock(x, p) = (1.0 - x[2][1])^2 + 100.0 * (x[2][2] - x[2][1]^2)^2
x0 = [p1 => 0.0, p2 => 0.0]
prob = OptimizationProblem(rosenbrock, x0, [])
sol = solve(prob, NelderMead())

Currently, one have to extract the various values manually, but this seems burdensome and also prone to potentially causing errors.

I have tried to create an OptimiationSystem, but

using Optimization, OptimizationOptimJL
@parameters p1 p2
rosenbrock(x, p) = (1.0 - x[2][1])^2 + 100.0 * (x[2][2] - x[2][1]^2)^2
@named sys = OptimizationSystem(rosenbrock, [p1, p2], [])
sys = complete(sys)
x0 = [p1 => 0.0, p2 => 0.0]
prob = OptimizationProblem(sys, x0, [])

gives a

ERROR: MethodError: no method matching collect_constants!(::Vector{SymbolicUtils.BasicSymbolic}, ::typeof(rosenbrock))
The function `collect_constants!` exists, but no method is defined for this combination of argument types.

[ChrisRackauckas]

But I don't understand your example here. It seems... just wrong? Why are you mixing a numerical function with a symbolic problem? We don't support that anywhere. Using parameters maps is fine if you have a symbolic equation:

using ModelingToolkit, Optimization, OptimizationOptimJL
@variables begin
    x = 1.0, [bounds = (-2.0, 2.0)]
    y = 3.0, [bounds = (-1.0, 3.0)]
end
@parameters a=1.0 b=1.0
rosenbrock = (a - x)^2 + b * (y - x^2)^2
@mtkbuild sys = OptimizationSystem(rosenbrock, [x, y], [a, b])
u0 = [y => 2.0]
p = [b => 100.0]

prob = OptimizationProblem(sys, u0, p, grad = true, hess = true)
u_opt = solve(prob, GradientDescent())

So closing because I think you just had the syntax wrong.

[TorkelE]

I was using this example as the minimal thing which would exemplify what I think we should be able to do. As mentioned I am interested in finding optimal parameter set for SciML models like Catalyst. Here are examples where we right now have to artificially extract the parameter vector before we run the optimization process, and then re-create the map to analyse the final parameter set: https://docs.sciml.ai/Catalyst/dev/inverse_problems/optimization_ode_param_fitting/, https://docs.sciml.ai/Catalyst/dev/inverse_problems/behaviour_optimisation/.

[ChrisRackauckas]

Well putting a numerical function with symbolic system definition isn't ever going to work out, that's basically an impedance mismatch. But there is a kind of feature here to be developed. One thing to think about is, for example, could you have an ODESystem as a subsystem to an OptimizationSystem? We could then do something like, generate code that first solves the ODE and then allows for using the solution variables in a symbolic cost function.

Another way to think about it though is extending an ODESystem to have constraints and a cost itself. This is what @vyudu is currently working towards, where without a loss function it's a boundary value problem, but with a loss function it would have an optimization interpretation. That would be solvable through BVP approaches, of which shooting BVP would be equivalent to what you're asking for here. I hope that we have enough of the system together in just the next month or two that we can show you this, and yes that would make it so you can symbolically define the ODE, any constraints on the solution (equality and inequality), a cost function on the solution, and then solve+optimize together to do things like inverse problems in a very easy way. Stay tuned... but yeah it won't look like this.

[TorkelE]

Well putting a numerical function with symbolic system definition isn't ever going to work out, that's basically an impedance mismatch.

I am not sure if I understand? Currently when I want to fit the parameters of an ODE I do:

ps_init = [:kB => 1.0, :kD => 1.0, :kP => 1.0]
oprob_base = ODEProblem(rn, u0, (0.0, 10.0), ps_init)
function objective_function(p, _)
    p = Pair.([:kB, :kD, :kP], p)
    oprob = remake(oprob_base; p)
    sol = solve(oprob; saveat = data_ts, save_idxs = :P, verbose = false, maxiters = 10000)
    SciMLBase.successful_retcode(sol) || return Inf
    return sum((sol .- data_vals) .^2)
end

and then later when I want to simualte the optimal solution I do:

oprob_fitted = remake(oprob_base; p = Pair.([:kB, :kD, :kP], optsol.u))
fitted_sol = solve(oprob_fitted)
plot!(fitted_sol; idxs = :P, label = "Fitted solution", linestyle = :dash, lw = 6, color = :light-blue)

It would seem fairly straightforward to have a routine where optimization internally "scales away" the map part or something. But input, output, and the optimization function you can treat it in the map form. That way you don't have to do

p = Pair.([:kB, :kD, :kP], p)

and

p = last.(p)

everywhere.

Long term something like you describe what VIncent is working on would be great as well.

[ChrisRackauckas]

It would seem fairly straightforward to have a routine where optimization internally "scales away" the map part or something.

No, what you're asking for as syntax is extremely non-trivial because you don't have a symbolic objective function. MTK is a symbolic modeling package.

[TorkelE]

Ok, maybe I am totally missing something here then. However, is there a standard for how one is supposed to do parameter fitting for MTK models?

[ChrisRackauckas]

That's the coming optimal control interface. It might just be easiest to come back to this in a few months when it's released