Constantify a parameter - New feature request

[H-Sax]

Following a discussion on slack I am putting this on here as a feature request.

From the MTK docs of the Acausal modelling of the RC circuit.

using ModelingToolkit, Plots, DifferentialEquations
@variables t
@connector function Pin(;name)
    sts = @variables v(t)=1.0 i(t)=1.0 [connect = Flow]
    ODESystem(Equation[], t, sts, []; name=name)
end
function Ground(;name)
    @named g = Pin()
    eqs = [g.v ~ 0]
    compose(ODESystem(eqs, t, [], []; name=name), g)
end
function OnePort(;name)
    @named p = Pin()
    @named n = Pin()
    sts = @variables v(t)=1.0 i(t)=1.0
    eqs = [
           v ~ p.v - n.v
           0 ~ p.i + n.i
           i ~ p.i
          ]
    compose(ODESystem(eqs, t, sts, []; name=name), p, n)
end
function Resistor(;name, R = 1.0)
    @named oneport = OnePort()
    @unpack v, i = oneport
    ps = @parameters R=R
    eqs = [
           v ~ i * R
          ]
    extend(ODESystem(eqs, t, [], ps; name=name), oneport)
end
function Capacitor(;name, C = 1.0)
    @named oneport = OnePort()
    @unpack v, i = oneport
    ps = @parameters C=C
    D = Differential(t)
    eqs = [
           D(v) ~ i / C
          ]
    extend(ODESystem(eqs, t, [], ps; name=name), oneport)
end
function ConstantVoltage(;name, V = 1.0)
    @named oneport = OnePort()
    @unpack v = oneport
    ps = @parameters V=V
    eqs = [
           V ~ v
          ]
    extend(ODESystem(eqs, t, [], ps; name=name), oneport)
end
R = 1.0
C = 1.0
V = 1.0
@named resistor = Resistor(R=R)
@named capacitor = Capacitor(C=C)
@named source = ConstantVoltage(V=V)
@named ground = Ground()
rc_eqs = [
          connect(source.p, resistor.p)
          connect(resistor.n, capacitor.p)
          connect(capacitor.n, source.n)
          connect(capacitor.n, ground.g)
         ]
@named _rc_model = ODESystem(rc_eqs, t)
@named rc_model = compose(_rc_model,
                          [resistor, capacitor, source, ground])
sys = structural_simplify(rc_model)
u0 = [
      capacitor.v => 0.0
     ]
prob = ODAEProblem(sys, u0, (0, 10.0))
sol = solve(prob, Tsit5())
plot(sol)

Given I want to then remake the problem and perform optimisation on only C and V in system. It would be a nice feature if we could hold R as a global constant and remake with only 2 parameters doing something like

function reparameterize(prob, parameter_map, u0)
    resistor.R = 2.0
   remake(prob; p=parameter_map, u0=u0)
end
   
p = [ 
    capacitor.C => 2.0
    source.V => 2.0
]
new_prob = reparameterize(prob, p, prob.u0)

What this means is that the dimensionalIty of the parameter space has decreased in size from 3 to 2 as R would now be considered a global constant, given this feature could be worked in, Performing reparameterize would allow us to reduced the parameter space size making it easier for inverse problem solves. optimisation etc.

By thinking stems from a much larger case where I have a model with 80 parameters and would only like to optimise 5, this feature would work nicely for this.

In the DifferentialEquations.jl framework one would use a closure to keep this parameter constant as seen in this example on discourse here https://discourse.julialang.org/t/ode-parameter-estimation-on-a-subset-of-the-parameters/28013

Hope that is clear :)

Thanks,
Harry

[jamesjscully]

You can use @variables v [tunable = false], and you can change this metadata after variable creation with setmetadata

[ChrisRackauckas]

But you'd also need to regenerate the ODESystem, so it's not very ergonomic.

[lamorton]

Here's my work-around for fitting models while changing which parameters are considered adjustable by the optimizer. ModelFittingDemo

[ChrisRackauckas]

@ven-k is this all handled by structural parameters?

[cartiery]

Are there any update on this topic ?

Because from what I saw, the number of "constant" tunable parameters (the ones not provided to the cost function) impact the optimization time for inverse modeling purpose for instance. Is it truly the case ?

If yes, the remake function, that change the tunable parameters (prob.p.tunable), would not be the best to use.

In that case, constantify parameters would enable to create a "generic" model (so to pay the discretization time once), save it, and when loading it again, being able to modify its parameters according to the experiment you are doing. So modifying the prob.p.constant, to not impact the optimization time further.

So something that would look like that :

prob = discretize(sys, ...)
Serialization.serialize("prob.jls", prob) ##save it
prob = Serialization.deserialize("discretized_prob.jls") ##load it
reparameterize(prob, parameter_map, u0)

[ChrisRackauckas]

v10 now does this, where the constants are held in p.constant so you can remake with respect to them without having to recompile. So this is closed.