ADNLSModel from ADNLPModels (OptimizationProblems)

[paraynaud]

The following code can test if an ADNLPModel is least square problem or not.

using ExpressionTreeForge
using ADNLPModels, ModelingToolkit
using OptimizationProblems, OptimizationProblems.ADNLPProblems

function get_expr_tree(adnlp :: ADNLPModel; x0 :: Vector{T}=copy(adnlp.meta.x0), kwargs...) where T <: Number
  n = adnlp.meta.nvar
  ModelingToolkit.@variables x[1:n]
  fun = adnlp.f(x)
  ex = ExpressionTreeForge.transform_to_expr_tree(fun)
  return ex, n, x0
end

using ..ExpressionTreeForge.M_power_operator

myand(a::Bool,b::Bool) = a && b

function isnls(nlp)
  ex, n, x0 = get_expr_tree(nlp)
  F_expr = delete_imbricated_plus(ex)
  test_square(expr) = expr.field == Power_operator{Int}(2)
  is_nls = mapreduce(test_square, myand, F_expr) :: Bool
  return is_nls 
end 

problems_names = OptimizationProblems.meta[!,:name] #261 problems
problems_symbols = map(name -> Symbol(name), problems_names)
problems = map( symbol -> getfield(OptimizationProblems.ADNLPProblems, symbol)(), problems_symbols)

res_isnls = []
index_is_nls = []
for (index,problem) in enumerate(problems)
  println(index)
  try
    bool = isnls(problem)
    push!(res_isnls, bool)
    push!(index_is_nls, index)
  catch 
    println("the ", index, "-th problem is unsupported")
  end 
end

length(res_isnls) #243 supported problems

cpt_isnls = 0
for (index, is_nls) in enumerate(res_isnls)
  cpt_isnls += is_nls
end 

cpt_isnls # 45 NLS problems

To summarize, among the 261 ADNLPModels: 243 are analyzed (without an error) and 45 are least square problems.
The name of the name least square problems are:

list_isnls_supported = filter(i-> res_isnls[i], 1:length(index_is_nls))
list_isnls = index_is_nls[list_isnls_supported]
name_nls = problems_names[list_isnls]

There is a bunch of operators that are not implemented, at least:

• logarithm;
• absolute value;
  producing unsupported problems.

[paraynaud]

To get the expected F as a String from a least square problem, you can apply

function F_nls(nlp)
  ex, n, x0 = get_expr_tree(nlp)
  F_expr = delete_imbricated_plus(ex)
  test_square(expr) = expr.field == Power_operator{Int}(2)
  is_nls = mapreduce(test_square, myand, F_expr)
  # expr.children[1] : the squared term
  F = (expr -> transform_to_Expr(expr.children[1])).(F_expr) 
  string_expr_vec = string.(F)
  string_modified_vec = (string_expr -> replace(string_expr, "MathOptInterface.VariableIndex("=>"", ")]"=>"]")).(string_expr_vec)
  string_F = "F(x) = [" * mapreduce(x->x, (x,y) -> x * ", " *y, string_modified_vec) *"]"
  return is_nls, string_F
end

F_nls can be used on a instantiated ADNLPModel least square to write the String of F required to produce an ADNLSModel.

[tmigot]

Awesome, thanks @paraynaud ! I build on your first message to open a first PR that modify the meta of the problems that you detected.

[tmigot]

For the second step. All the problems end with the following lines

  return ADNLPModels.ADNLPModel(f, x0, name = "arglina"; kwargs...)

What about we make a script that replaces return ADNLPModels.ADNLPModel(f, x0 by return ADNLPModels.ADNLSModel(F, x0, nequ with nequ to be determined?
Then, add the string with F in just the line above this one.

[paraynaud]

I don't think it will work, because as n change the size of F change too .

However, if we have the constructor of ADNLSModel from a ADNLPModel, we can replace return ADNLPModels.ADNLPModel(f, x0..) by return ADNLPModels.ADNLSModel(ADNLPModels.ADNLPModel(f, x0...)).

We should implement it in NLPModelsModifiers, is this a problem to add it in the dependencies of OptimizationProblems.jl?

[tmigot]

I don't think it will work, because as n change the size of F change too .

Yeah, I see, that would be some files to be edited manually... Still, it looks like a cleanest solution.

I also like that the other construction you propose, and like the idea of adding to NLPModelsModifiers.
Do you think it would this lead to an additional computation cost every time we evaluate the residual?

[paraynaud]

I don't think there is an additional computation cost for the residual evaluation.

But there is certainly an additional computation cost when we define the ADNLSModel, particularly if the new constructor write string_F in a temporary julia file to evaluate afterward F with include("temporary_file.jl").