Solver revamp src folder

Author: abelsiqueira

Project.toml

@@ -3,18 +3,18 @@ uuid = "ff4d7338-4cf1-434d-91df-b86cb86fb843"
 version = "0.1.0"
 
 [deps]
-NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
+Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
+OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 
 [compat]
-NLPModels = "0.14"
 julia = "^1.3.0"
 
 [extras]
-ADNLPModels = "54578032-b7ea-4c30-94aa-7cbd1cce6c9a"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["ADNLPModels", "LinearAlgebra", "Logging", "Test"]
+test = ["LinearAlgebra", "Logging", "Random", "Test"]

src/SolverCore.jl

@@ -1,12 +1,16 @@
 module SolverCore
 
 # stdlib
-using Printf
+using Logging, Printf
+using OrderedCollections
 
-# our packages
-using NLPModels
+include("solver.jl")
+include("output.jl")
 
 include("logger.jl")
-include("stats.jl")
+include("parameters.jl")
+include("traits.jl")
+
+include("grid-search-tuning.jl")
 
 end

src/grid-search-tuning.jl

@@ -0,0 +1,100 @@
+export grid_search_tune
+
+# TODO: Issue: For grid_search_tune to work, we need to define `reset!`, but LinearOperators also define reset!
+function reset! end
+
+# TODO: Decide success and costs of grid_search_tune below
+
+"""
+    solver, results = grid_search_tune(SolverType, problems; kwargs...)
+
+Simple tuning of solver `SolverType` by grid search, on `problems`, which should be iterable.
+The following keyword arguments are available:
+- `success`: A function to be applied on a solver output that returns whether the problem has terminated succesfully. Defaults to `o -> o.status == :first_order`.
+- `costs`: A vector of cost functions and penalties. Each element is a tuple of two elements. The first is a function to be applied to the output of the solver, and the second is the cost when the solver fails (see `success` above) or throws an error. Defaults to
+```
+[
+  (o -> o.elapsed_time, 100.0),
+  (o -> o.counters.neval_obj + o.counters.neval_cons, 1000),
+  (o -> !success(o), 1),
+]
+```
+which represent the total elapsed_time (with a penalty of 100.0 for failures); the number of objective and constraints functions evaluations (with a penalty of 1000 for failures); and the number of failures.
+- `grid_length`: The number of points in the ranges of the grid for continuous points.
+- `solver_kwargs`: Arguments to be passed to the solver. Note: use this to set the stopping parameters, but not the other parameters being optimize.
+- Any parameters accepted by the `Solver`: a range to be used instead of the default range.
+
+The default ranges are based on the parameters types, and are as follows:
+- `:real`: linear range from `:min` to `:max` with `grid_length` points.
+- `:log`: logarithmic range from `:min` to `:max` with `grid_length` points. Computed by exp of linear range of `log(:min)` to `log(:max)`.
+- `:bool`: either `false` or `true`.
+- `:int`: integer range from `:min` to `:max`.
+"""
+function grid_search_tune(
+  ::Type{Solver},
+  problems;
+  success = o -> o.status == :first_order,
+  costs = [(o -> o.elapsed_time, 100.0), (o -> !success(o), 1)],
+  grid_length = 10,
+  solver_kwargs = Dict(),
+  kwargs...,
+) where {Solver <: AbstractSolver}
+  solver_params = parameters(Solver)
+  params = OrderedDict()
+  for (k, v) in pairs(solver_params)
+    if v[:type] <: AbstractFloat && (!haskey(v, :scale) || v[:scale] == :linear)
+      params[k] = LinRange(v[:min], v[:max], grid_length)
+    elseif v[:type] <: AbstractFloat && v[:scale] == :log
+      params[k] = exp.(LinRange(log(v[:min]), log(v[:max]), grid_length))
+    elseif v[:type] == Bool
+      params[k] = (false, true)
+    elseif v[:type] <: Integer
+      params[k] = v[:min]:v[:max]
+    end
+  end
+  for (k, v) in kwargs
+    params[k] = v
+  end
+
+  # Precompiling
+  problem = first(problems)
+  try
+    solver = Solver(problem)
+    output = with_logger(NullLogger()) do
+      solve!(solver, problem)
+    end
+  finally
+    finalize(problem)
+  end
+
+  cost(θ) = begin
+    total_cost = [zero(x[2]) for x in costs]
+    for problem in problems
+      reset!(problem)
+      try
+        solver = Solver(problem)
+        P = (k => θi for (k, θi) in zip(keys(solver_params), θ))
+        output = with_logger(NullLogger()) do
+          solve!(solver, problem; P...)
+        end
+        for (i, c) in enumerate(costs)
+          if success(output)
+            total_cost[i] += (c[1])(output)
+          else
+            total_cost[i] += c[2]
+          end
+        end
+      catch ex
+        for (i, c) in enumerate(costs)
+          total_cost[i] += c[2]
+        end
+        @error ex
+      finally
+        finalize(problem)
+      end
+    end
+    total_cost
+  end
+
+  [θ => cost(θ) for θ in Iterators.product(values(params)...)]
+end

src/output.jl

@@ -0,0 +1,36 @@
+export AbstractSolverOutput
+
+# TODO: Define the required fields and API for all Outputs
+"""
+    AbstractSolverOutput{T}
+
+Base type for output of JSO-compliant solvers.
+An output must have at least the following:
+- `status :: Symbol`
+- `solution`
+"""
+abstract type AbstractSolverOutput{T} end
+
+# TODO: Decision: Should STATUSES be fixed? Should it be all here?
+const STATUSES = Dict(
+  :exception => "unhandled exception",
+  :first_order => "first-order stationary",
+  :acceptable => "solved to within acceptable tolerances",
+  :infeasible => "problem may be infeasible",
+  :max_eval => "maximum number of function evaluations",
+  :max_iter => "maximum iteration",
+  :max_time => "maximum elapsed time",
+  :neg_pred => "negative predicted reduction",
+  :not_desc => "not a descent direction",
+  :small_residual => "small residual",
+  :small_step => "step too small",
+  :stalled => "stalled",
+  :unbounded => "objective function may be unbounded from below",
+  :unknown => "unknown",
+  :user => "user-requested stop",
+)
+
+function Base.show(io::IO, output::AbstractSolverOutput)
+  println(io, "Solver output of type $(typeof(output))")
+  println(io, "Status: $(STATUSES[output.status])")
+end

src/parameters.jl

@@ -0,0 +1,46 @@
+export parameters, are_valid_parameters
+
+"""
+    named_tuple = parameters(solver)
+    named_tuple = parameters(SolverType)
+    named_tuple = parameters(SolverType{T})
+
+Return the parameters of a `solver`, or of the type `SolverType`.
+You can specify the type `T` of the `SolverType`.
+The returned structure is a nested NamedTuple.
+Each key of `named_tuple` is the name of a parameter, and its value is a NamedTuple containing
+- `default`: The default value of the parameter.
+- `type`: The type of the parameter, such as `Int`, `Float64`, `T`, etc.
+
+and possibly other values depending on the `type`.
+Some possibilies are:
+
+- `scale`: How to explore the domain
+  - `:linear`: A continuous value within a range
+  - `:log`: A positive continuous value that should be explored logarithmically (like 10⁻², 10⁻¹, 1, 10).
+- `min`: Minimum value.
+- `max`: Maximum value.
+
+Solvers should define
+
+    SolverCore.parameters(::Type{Solver{T}}) where T
+"""
+function parameters end
+
+parameters(::Type{S}) where {S <: AbstractSolver} = parameters(S{Float64})
+parameters(::S) where {S <: AbstractSolver} = parameters(S)
+
+"""
+    are_valid_parameters(solver, args...)
+
+Return whether the parameters given in `args` are valid for `solver`.
+The order of the parameters must be the same as in `parameters(solver)`.
+
+Solvers should define
+
+    SolverCore.are_valid_parameters(::Type{Solver{T}}, arg1, arg2, ...) where T
+"""
+function are_valid_parameters end
+are_valid_parameters(::Type{S}, args...) where {S <: AbstractSolver} =
+  are_valid_parameters(S{Float64}, args...)
+are_valid_parameters(::S, args...) where {S <: AbstractSolver} = are_valid_parameters(S, args...)

src/solver.jl

@@ -0,0 +1,26 @@
+export AbstractSolver, solve!
+
+# TODO: Define the required fields and API for all Solvers
+"""
+    AbstractSolver
+
+Base type for JSO-compliant solvers.
+A solver must have three members:
+- `initialized :: Bool`, indicating whether the solver was initialized
+- `params :: Dict`, a dictionary of parameters for the solver
+- `workspace`, a named tuple with arrays used by the solver.
+"""
+abstract type AbstractSolver{T} end
+
+function Base.show(io::IO, solver::AbstractSolver)
+  println(io, "Solver $(typeof(solver))")
+end
+
+"""
+    output = solve!(solver, problem)
+
+Solve `problem` with `solver`.
+"""
+function solve! end
+
+# TODO: Define general constructors that automatically call `solve!`, etc.?