Unsafe cached backend

[blegat]

The unsafe_backend is very useful to get info about the backend, especially with the new show methods in MOI. But it's much less useful when the backend does not support any getter.
For instance, this is not so helpful:

julia> model = Model(SDPLR.Optimizer);

julia> unsafe_backend(model)
SDPLR.Optimizer
├ ObjectiveSense: unknown
├ ObjectiveFunctionType: unknown
├ NumberOfVariables: unknown
└ NumberOfConstraints: unknown

However, if there is a cache, then it would give all the information about the model.
We could have unsafe_backend(model, with_cache = true) that returns the CachingOptimizer that is inside the bridges so that the user has both the optimizer and the corresponding cache.
If there is no cache, this would provide the helpful time to the user that he should use Model(..., with_cache_type = Float64)!

julia> model = Model(SDPLR.Optimizer);

julia> unsafe_backend(model, with_cache = true)
ERROR: The optimizer does not have a cache, either use  `with_cache = false` or use `with_cache_type = Float64` in `Model` or `set_optimizer`

Then the user would do

julia> model = Model(SDPLR.Optimizer, with_cache_type = Float64)

julia> @variable(model, x)
x

julia> @variable(model, X[1:2, 1:2] in PSDCone())
2×2 Symmetric{VariableRef, Matrix{VariableRef}}:
 X[1,1]  X[1,2]
 X[1,2]  X[2,2]

julia> @constraint(model, x == sum(X))
x - X[1,1] - 2 X[1,2] - X[2,2] = 0

julia> optimize!(model)

            ***   SDPLR 1.03-beta   ***

===================================================
 major   minor        val        infeas      time  
---------------------------------------------------
    1        0   8.68291638e-05  2.6e-02       0
    2        1   8.68839195e-04  1.2e-02       0
    3        3  -4.28299100e-05  1.3e-03       0
    4        4   1.09718980e-05  5.9e-04       0
    5        5   4.40824487e-31  4.5e-17       0
===================================================

DIMACS error measures: 4.47e-17 0.00e+00 0.00e+00 1.27e-14 0.00e+00 5.75e-31


julia> backend(model).optimizer.model # That will be unsafe_backend(model, with_cache = true)
MOIU.CachingOptimizer
├ state: ATTACHED_OPTIMIZER
├ mode: AUTOMATIC
├ model_cache: MOIU.UniversalFallback{MOIU.Model{Float64}}
│ ├ ObjectiveSense: FEASIBILITY_SENSE
│ ├ ObjectiveFunctionType: MOI.ScalarAffineFunction{Float64}
│ ├ NumberOfVariables: 5
│ └ NumberOfConstraints: 3
│   ├ MOI.ScalarAffineFunction{Float64} in MOI.EqualTo{Float64}: 1
│   ├ MOI.VectorOfVariables in MOI.Nonnegatives: 1
│   └ MOI.VectorOfVariables in MOI.PositiveSemidefiniteConeTriangle: 1
└ optimizer: SDPLR.Optimizer
  ├ ObjectiveSense: unknown
  ├ ObjectiveFunctionType: unknown
  ├ NumberOfVariables: unknown
  └ NumberOfConstraints: unknown

This model information, along with print_active_bridges would be essential in conic programming for the user to understand what the bridges did

[odow]

So if there are multiple caches and bridges, you want the last cache before the optimizer? Even if we added this, it's complicated to communicate to a user.

This warning is pertinent:

JuMP.jl/src/JuMP.jl

Lines 463 to 465 in f659f18

	**This function should only be used by advanced users looking to access
	low-level solver-specific functionality. It has a high-risk of incorrect usage.
	We strongly suggest you use the alternative suggested below.**

You could do instead:

using JuMP, SDPLR
inner = MOI.instantiate(
    SDPLR.Optimizer;
    with_cache_type = Float64,
    with_bridge_type = Float64,
)
model = direct_model(inner)
backend(model)
MOI.Bridges.print_active_bridges(inner)

If you want something outside the defaults, drop down to MOI for full control.

I don't think we should go making JuMP more complicated for the sake of niche optimizers like SDPLR.

[blegat]

I wouldn't say this is niche. I think all users of conic solvers would be (or at least they should be ;) ) interested in getting stats in what is the sizes of the problem that arrived at the solver after bridging. No conic solver (except Mosek perhaps) supports any getter so you can't get the stats with unsafe_backend. You could rely on the printing of the solvers but these are often a bit cryptic and you need to know the internal way the solver names things to understand. If it was as easy as printing unsafe_backend(model, with_cache = true), then it would help a lot.

[joaquimg]

A very flexible alternative would be:
unsafe_backend(mode, stop_at_first = MOI.Utilities.CachingOptimizer). Or maybe stop_at_last = ...

[blegat]

Yes but the user won't know what to use there and it won't be so readable. Getting the unsafe backend with the cache is a simple concept to understand and it's all the user needs to know

[joaquimg]

Yeah, but there may be a POI.Optimizer in the middle, and then the user will be missing parameters. So I think there will always be a reason to stop at a particular layer. I have needed to get many of the layers for different reasons.

[blegat]

unsafe_backend only unwraps the first caching optimizer and then the bridge layer. If with_cache = true, it would then unwrap the inner cache as well.
If your using Dualization or POI then you will face a Dualization or POI level then. If we want to go inner then these need to define an API to get the inner model as well. It could be a model attribute

[odow]

I still think this is the wrong approach. There's a lot of complexity here, and having more than one concept for what the unsafe backend is is going to cause confusion. What is right for @blegat when you are mucking around writing conic solver wrappers is not necessarily what is right for users.

[odow]

How about something like this:

julia> using JuMP, SCS

julia> function optimizer_layers(model::GenericModel)
           return _optimizer_layers!(backend(model))
       end
optimizer_layers (generic function with 1 method)

julia> _backend(::MOI.ModelLike) = nothing
_backend (generic function with 4 methods)

julia> _backend(model::MOI.Bridges.LazyBridgeOptimizer) = model.model
_backend (generic function with 4 methods)

julia> _backend(model::MOI.Utilities.CachingOptimizer) = model.optimizer
_backend (generic function with 4 methods)

julia> _backend(model::MOI.Utilities.UniversalFallback) = model.model
_backend (generic function with 4 methods)

julia> _optimizer_layers!(::Nothing, layers::Vector{MOI.ModelLike}) = layers
_optimizer_layers! (generic function with 5 methods)

julia> function _optimizer_layers!(
           model::MOI.ModelLike,
           layers::Vector{MOI.ModelLike} = MOI.ModelLike[],
       )
           push!(layers, model)
           return _optimizer_layers!(_backend(model), layers)
       end
_optimizer_layers! (generic function with 5 methods)

julia> model = Model(SCS.Optimizer)
A JuMP Model
├ solver: SCS
├ objective_sense: FEASIBILITY_SENSE
├ num_variables: 0
├ num_constraints: 0
└ Names registered in the model: none

julia> @variable(model, x >= 0)
x

julia> @constraint(model, x^2 <= 1)
x² ≤ 1

julia> optimize!(model)
------------------------------------------------------------------
	       SCS v3.2.7 - Splitting Conic Solver
	(c) Brendan O'Donoghue, Stanford University, 2012
------------------------------------------------------------------
problem:  variables n: 1, constraints m: 4
cones: 	  l: linear vars: 1
	  q: soc vars: 3, qsize: 1
settings: eps_abs: 1.0e-04, eps_rel: 1.0e-04, eps_infeas: 1.0e-07
	  alpha: 1.50, scale: 1.00e-01, adaptive_scale: 1
	  max_iters: 100000, normalize: 1, rho_x: 1.00e-06
	  acceleration_lookback: 10, acceleration_interval: 10
	  compiled with openmp parallelization enabled
lin-sys:  sparse-direct-amd-qdldl
	  nnz(A): 2, nnz(P): 0
------------------------------------------------------------------
 iter | pri res | dua res |   gap   |   obj   |  scale  | time (s)
------------------------------------------------------------------
     0| 1.41e+00  0.00e+00  0.00e+00  0.00e+00  1.00e-01  1.38e-04 
    25| 4.19e-08  0.00e+00  0.00e+00  0.00e+00  1.00e-01  1.93e-04 
------------------------------------------------------------------
status:  solved
timings: total: 1.97e-04s = setup: 6.07e-05s + solve: 1.37e-04s
	 lin-sys: 3.98e-06s, cones: 2.79e-06s, accel: 1.34e-06s
------------------------------------------------------------------
objective = 0.000000
------------------------------------------------------------------

julia> layers = optimizer_layers(model)
4-element Vector{MathOptInterface.ModelLike}:
 MOIU.CachingOptimizer
├ state: ATTACHED_OPTIMIZER
├ mode: AUTOMATIC
├ model_cache: MOIU.UniversalFallback{MOIU.Model{Float64}}
│ ├ ObjectiveSense: FEASIBILITY_SENSE
│ ├ ObjectiveFunctionType: MOI.ScalarAffineFunction{Float64}
│ ├ NumberOfVariables: 1
│ └ NumberOfConstraints: 2
│   ├ MOI.ScalarQuadraticFunction{Float64} in MOI.LessThan{Float64}: 1
│   └ MOI.VariableIndex in MOI.GreaterThan{Float64}: 1
└ optimizer: MOIB.LazyBridgeOptimizer{MOIU.CachingOptimizer{SCS.Optimizer, MOIU.UniversalFallback{MOIU.Model{Float64}}}}
  ├ Variable bridges: none
  ├ Constraint bridges:
  │ ├ MOIB.Constraint.QuadtoSOCBridge{Float64}
  │ ├ MOIB.Constraint.RSOCtoSOCBridge{Float64, MOI.VectorAffineFunction{Float64}, MOI.VectorAffineFunction{Float64}}
  │ └ MOIB.Constraint.VectorizeBridge{Float64, MOI.VectorAffineFunction{Float64}, MOI.Nonnegatives, MOI.VariableIndex}
  ├ Objective bridges: none
  └ model: MOIU.CachingOptimizer
    ├ state: EMPTY_OPTIMIZER
    ├ mode: AUTOMATIC
    ├ model_cache: MOIU.UniversalFallback{MOIU.Model{Float64}}
    │ ├ ObjectiveSense: FEASIBILITY_SENSE
    │ ├ ObjectiveFunctionType: MOI.ScalarAffineFunction{Float64}
    │ ├ NumberOfVariables: 1
    │ └ NumberOfConstraints: 2
    │   ├ MOI.VectorAffineFunction{Float64} in MOI.Nonnegatives: 1
    │   └ MOI.VectorAffineFunction{Float64} in MOI.SecondOrderCone: 1
    └ optimizer: SCS.Optimizer
      ├ ObjectiveSense: unknown
      ├ ObjectiveFunctionType: unknown
      ├ NumberOfVariables: unknown
      └ NumberOfConstraints: unknown
 MOIB.LazyBridgeOptimizer{MOIU.CachingOptimizer{SCS.Optimizer, MOIU.UniversalFallback{MOIU.Model{Float64}}}}
├ Variable bridges: none
├ Constraint bridges:
│ ├ MOIB.Constraint.QuadtoSOCBridge{Float64}
│ ├ MOIB.Constraint.RSOCtoSOCBridge{Float64, MOI.VectorAffineFunction{Float64}, MOI.VectorAffineFunction{Float64}}
│ └ MOIB.Constraint.VectorizeBridge{Float64, MOI.VectorAffineFunction{Float64}, MOI.Nonnegatives, MOI.VariableIndex}
├ Objective bridges: none
└ model: MOIU.CachingOptimizer
  ├ state: EMPTY_OPTIMIZER
  ├ mode: AUTOMATIC
  ├ model_cache: MOIU.UniversalFallback{MOIU.Model{Float64}}
  │ ├ ObjectiveSense: FEASIBILITY_SENSE
  │ ├ ObjectiveFunctionType: MOI.ScalarAffineFunction{Float64}
  │ ├ NumberOfVariables: 1
  │ └ NumberOfConstraints: 2
  │   ├ MOI.VectorAffineFunction{Float64} in MOI.Nonnegatives: 1
  │   └ MOI.VectorAffineFunction{Float64} in MOI.SecondOrderCone: 1
  └ optimizer: SCS.Optimizer
    ├ ObjectiveSense: unknown
    ├ ObjectiveFunctionType: unknown
    ├ NumberOfVariables: unknown
    └ NumberOfConstraints: unknown
 MOIU.CachingOptimizer
├ state: EMPTY_OPTIMIZER
├ mode: AUTOMATIC
├ model_cache: MOIU.UniversalFallback{MOIU.Model{Float64}}
│ ├ ObjectiveSense: FEASIBILITY_SENSE
│ ├ ObjectiveFunctionType: MOI.ScalarAffineFunction{Float64}
│ ├ NumberOfVariables: 1
│ └ NumberOfConstraints: 2
│   ├ MOI.VectorAffineFunction{Float64} in MOI.Nonnegatives: 1
│   └ MOI.VectorAffineFunction{Float64} in MOI.SecondOrderCone: 1
└ optimizer: SCS.Optimizer
  ├ ObjectiveSense: unknown
  ├ ObjectiveFunctionType: unknown
  ├ NumberOfVariables: unknown
  └ NumberOfConstraints: unknown
 SCS.Optimizer
├ ObjectiveSense: unknown
├ ObjectiveFunctionType: unknown
├ NumberOfVariables: unknown
└ NumberOfConstraints: unknown

[odow]

I'm still not convinced that we need this.

[blegat]

Given what we discussed on the JuMP-dev call on Thursday, we can close if we explain how to deduce what the inner optimizer receives using show(backend(model)). It can be next to the print_active_bridges part or the part on dualization

[odow]

I thought the conclusion was that we should add the optimizer_layers function?

[blegat]

Sounds good, the disadvantage of show(backend(model)) is that it prints the same model twice (once for the CachingOptimizer and once for the cache). With optimizer_layers, if we print only the summary of each layer and we ignore the caches, it will fix that issues.

[odow]

I think my conclusion with this is that we don't need it.