Reorganised dependencies

Author: kaandocal

Project.toml

@@ -6,16 +6,12 @@ version = "1.2.0"
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 ConsoleProgressMonitor = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b"
-DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
 DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
-Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 LoggingExtras = "e6f89c97-d47a-5376-807f-9c37f3926c36"
-ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
-Optim = "429524aa-4258-5aef-a3af-852621145aeb"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 ProgressLogging = "33c8b6b6-d38a-422a-b730-caa89a2f386c"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
@@ -29,15 +25,11 @@ Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 [compat]
 ArrayInterface = "2.13, 3.0"
 ConsoleProgressMonitor = "0.1"
-DiffEqBase = "6.48.1"
 DiffResults = "1.0"
 DocStringExtensions = "0.8"
 FiniteDiff = "2.5"
-Flux = "0.11, 0.12"
 ForwardDiff = "0.10"
 LoggingExtras = "0.4"
-ModelingToolkit = "5.2"
-Optim = "1"
 ProgressLogging = "0.1"
 Reexport = "0.2, 1.0"
 Requires = "1.0"
@@ -53,13 +45,16 @@ BlackBoxOptim = "a134a8b2-14d6-55f6-9291-3336d3ab0209"
 CMAEvolutionStrategy = "8d3b24bd-414e-49e0-94fb-163cc3a3e411"
 DiffEqFlux = "aae7a2af-3d4f-5e19-a356-7da93b79d9d0"
 Evolutionary = "86b6b26d-c046-49b6-aa0b-5f0f74682bd6"
+Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
+ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
 NLopt = "76087f3c-5699-56af-9a33-bf431cd00edd"
+Optim = "429524aa-4258-5aef-a3af-852621145aeb"
 OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["BlackBoxOptim", "Evolutionary", "DiffEqFlux", "IterTools", "OrdinaryDiffEq", "NLopt", "CMAEvolutionStrategy", "Pkg", "Random", "SafeTestsets", "Test"]
+test = ["Flux", "ModelingToolkit", "Optim", "BlackBoxOptim", "Evolutionary", "DiffEqFlux", "IterTools", "OrdinaryDiffEq", "NLopt", "CMAEvolutionStrategy", "Pkg", "Random", "SafeTestsets", "Test"]

src/GalacticOptim.jl

@@ -5,21 +5,15 @@ module GalacticOptim
 
 using DocStringExtensions
 using Reexport
-@reexport using DiffEqBase
 @reexport using SciMLBase
 using Requires
 using DiffResults, ForwardDiff, Zygote, ReverseDiff, Tracker, FiniteDiff
-@reexport using Optim, Flux
 using Logging, ProgressLogging, Printf, ConsoleProgressMonitor, TerminalLoggers, LoggingExtras
 using ArrayInterface, Base.Iterators
 
 using ForwardDiff: DEFAULT_CHUNK_THRESHOLD
 import SciMLBase: OptimizationProblem, OptimizationFunction, AbstractADType, __solve
 
-import ModelingToolkit
-import ModelingToolkit: AutoModelingToolkit
-export AutoModelingToolkit
-
 include("solve.jl")
 include("function.jl")
 

src/function.jl

@@ -30,10 +30,10 @@ function instantiate_function(f, x, ::AbstractADType, p, num_cons = 0)
     cons_j = f.cons_j === nothing ? nothing : (res,x)->f.cons_j(res,x,p)
     cons_h = f.cons_h === nothing ? nothing : (res,x)->f.cons_h(res,x,p)
 
-    OptimizationFunction{true,DiffEqBase.NoAD,typeof(f.f),typeof(grad),
+    OptimizationFunction{true,SciMLBase.NoAD,typeof(f.f),typeof(grad),
                          typeof(hess),typeof(hv),typeof(cons),
                          typeof(cons_j),typeof(cons_h)}(f.f,
-                         DiffEqBase.NoAD(),grad,hess,hv,cons,
+                         SciMLBase.NoAD(),grad,hess,hv,cons,
                          cons_j,cons_h)
 end
 
@@ -138,7 +138,7 @@ function instantiate_function(f, x, ::AutoZygote, p, num_cons = 0)
     return OptimizationFunction{false,AutoZygote,typeof(f),typeof(grad),typeof(hess),typeof(hv),Nothing,Nothing,Nothing}(f,AutoZygote(),grad,hess,hv,nothing,nothing,nothing)
 end
 
-function instantiate_function(f, x, ::AutoReverseDiff, p=DiffEqBase.NullParameters(), num_cons = 0)
+function instantiate_function(f, x, ::AutoReverseDiff, p=SciMLBase.NullParameters(), num_cons = 0)
     num_cons != 0 && error("AutoReverseDiff does not currently support constraints")
 
     _f = (θ, args...) -> first(f.f(θ,p, args...))

src/solve.jl

@@ -57,271 +57,15 @@ macro withprogress(progress, exprs...)
         $(exprs[end])
       end
     end |> esc
-  end
-
-function __solve(prob::OptimizationProblem, opt, data = DEFAULT_DATA;
-                 maxiters::Number = 0, cb = (args...) -> (false),
-                 progress = false, save_best = true, kwargs...)
-
-    if data != DEFAULT_DATA
-      maxiters = length(data)
-    else
-      if maxiters <= 0.0
-        error("The number of maxiters has to be a non-negative and non-zero number.")
-      end
-      data = take(data, maxiters)
-    end
-
-    # Flux is silly and doesn't have an abstract type on its optimizers, so assume
-    # this is a Flux optimizer
-    θ = copy(prob.u0)
-    ps = Flux.params(θ)
-
-    t0 = time()
-
-    local x, min_err, _loss
-    min_err = typemax(eltype(prob.u0)) #dummy variables
-    min_opt = 1
-
-    f = instantiate_function(prob.f,prob.u0,prob.f.adtype,prob.p)
-
-    @withprogress progress name="Training" begin
-      for (i,d) in enumerate(data)
-        gs = Flux.Zygote.gradient(ps) do
-            x = prob.f(θ,prob.p, d...)
-            first(x)
-          end
-        x = f.f(θ, prob.p, d...)
-        cb_call = cb(θ, x...)
-        if !(typeof(cb_call) <: Bool)
-          error("The callback should return a boolean `halt` for whether to stop the optimization process. Please see the sciml_train documentation for information.")
-        elseif cb_call
-          break
-        end
-        msg = @sprintf("loss: %.3g", x[1])
-        progress && ProgressLogging.@logprogress msg i/maxiters
-        Flux.update!(opt, ps, gs)
-
-        if save_best
-          if first(x) < first(min_err)  #found a better solution
-            min_opt = opt
-            min_err = x
-          end
-          if i == maxiters  #Last iteration, revert to best.
-            opt = min_opt
-            cb(θ,min_err...)
-          end
-        end
-      end
-    end
-
-    _time = time()
-
-    SciMLBase.build_solution(prob, opt, θ, x[1])
-    # here should be build_solution to create the output message
 end
 
-
-decompose_trace(trace::Optim.OptimizationTrace) = last(trace)
 decompose_trace(trace) = trace
 
-function __solve(prob::OptimizationProblem, opt::Optim.AbstractOptimizer,
-                 data = DEFAULT_DATA;
-                 maxiters = nothing,
-                 cb = (args...) -> (false),
-                 progress = false,
-                 kwargs...)
-    local x, cur, state
-
-    if data != DEFAULT_DATA
-        maxiters = length(data)
-    end
-
-    cur, state = iterate(data)
-
-    function _cb(trace)
-        cb_call = opt == NelderMead() ? cb(decompose_trace(trace).metadata["centroid"],x...) : cb(decompose_trace(trace).metadata["x"],x...)
-        if !(typeof(cb_call) <: Bool)
-            error("The callback should return a boolean `halt` for whether to stop the optimization process.")
-        end
-        cur, state = iterate(data, state)
-        cb_call
-    end
-
-    if !(isnothing(maxiters)) && maxiters <= 0.0
-        error("The number of maxiters has to be a non-negative and non-zero number.")
-    elseif !(isnothing(maxiters))
-        maxiters = convert(Int, maxiters)
-    end
-
-    f = instantiate_function(prob.f,prob.u0,prob.f.adtype,prob.p)
-
-    !(opt isa Optim.ZerothOrderOptimizer) && f.grad === nothing && error("Use OptimizationFunction to pass the derivatives or automatically generate them with one of the autodiff backends")
-
-    _loss = function(θ)
-        x = f.f(θ, prob.p, cur...)
-        return first(x)
-    end
-
-    fg! = function (G,θ)
-        if G !== nothing
-            f.grad(G, θ, cur...)
-        end
-        return _loss(θ)
-    end
-
-    if opt isa Optim.KrylovTrustRegion
-        optim_f = Optim.TwiceDifferentiableHV(_loss, fg!, (H,θ,v) -> f.hv(H,θ,v,cur...), prob.u0)
-    else
-        optim_f = TwiceDifferentiable(_loss, (G, θ) -> f.grad(G, θ, cur...), fg!, (H,θ) -> f.hess(H,θ,cur...), prob.u0)
-    end
-
-    original = Optim.optimize(optim_f, prob.u0, opt,
-                              !(isnothing(maxiters)) ?
-                                Optim.Options(;extended_trace = true,
-                                               callback = _cb,
-                                               iterations = maxiters,
-                                               kwargs...) :
-                                Optim.Options(;extended_trace = true,
-                                               callback = _cb, kwargs...))
-    SciMLBase.build_solution(prob, opt, original.minimizer,
-                             original.minimum; original=original)
-end
-
-function __solve(prob::OptimizationProblem, opt::Union{Optim.Fminbox,Optim.SAMIN},
-                 data = DEFAULT_DATA;
-                 maxiters = nothing,
-                 cb = (args...) -> (false),
-                 progress = false,
-                 kwargs...)
-
-    local x, cur, state
-
-    if data != DEFAULT_DATA
-        maxiters = length(data)
-    end
-
-    cur, state = iterate(data)
-
-    function _cb(trace)
-        cb_call = !(opt isa Optim.SAMIN) && opt.method == NelderMead() ? cb(decompose_trace(trace).metadata["centroid"],x...) : cb(decompose_trace(trace).metadata["x"],x...)
-        if !(typeof(cb_call) <: Bool)
-            error("The callback should return a boolean `halt` for whether to stop the optimization process.")
-        end
-        cur, state = iterate(data, state)
-        cb_call
-    end
-
-    if !(isnothing(maxiters)) && maxiters <= 0.0
-        error("The number of maxiters has to be a non-negative and non-zero number.")
-    elseif !(isnothing(maxiters))
-        maxiters = convert(Int, maxiters)
-    end
-
-    f = instantiate_function(prob.f,prob.u0,prob.f.adtype,prob.p)
-
-    !(opt isa Optim.ZerothOrderOptimizer) && f.grad === nothing && error("Use OptimizationFunction to pass the derivatives or automatically generate them with one of the autodiff backends")
-
-    _loss = function(θ)
-        x = f.f(θ, prob.p, cur...)
-        return first(x)
-    end
-    fg! = function (G,θ)
-        if G !== nothing
-            f.grad(G, θ, cur...)
-        end
-
-        return _loss(θ)
-    end
-    optim_f = OnceDifferentiable(_loss, (G, θ) -> f.grad(G, θ, cur...), fg!, prob.u0)
-
-    original = Optim.optimize(optim_f, prob.lb, prob.ub, prob.u0, opt,
-                              !(isnothing(maxiters)) ? Optim.Options(;
-                              extended_trace = true, callback = _cb,
-                              iterations = maxiters, kwargs...) :
-                              Optim.Options(;extended_trace = true,
-                              callback = _cb, kwargs...))
-    SciMLBase.build_solution(prob, opt, original.minimizer,
-                             original.minimum; original=original)
-end
-
-
-function __solve(prob::OptimizationProblem, opt::Optim.ConstrainedOptimizer,
-                 data = DEFAULT_DATA;
-                 maxiters = nothing,
-                 cb = (args...) -> (false),
-                 progress = false,
-                 kwargs...)
-
-    local x, cur, state
-
-    if data != DEFAULT_DATA
-        maxiters = length(data)
-    end
-
-    cur, state = iterate(data)
-
-      function _cb(trace)
-      cb_call = cb(decompose_trace(trace).metadata["x"],x...)
-      if !(typeof(cb_call) <: Bool)
-          error("The callback should return a boolean `halt` for whether to stop the optimization process.")
-      end
-      cur, state = iterate(data, state)
-      cb_call
-    end
-
-    if !(isnothing(maxiters)) && maxiters <= 0.0
-        error("The number of maxiters has to be a non-negative and non-zero number.")
-    elseif !(isnothing(maxiters))
-        maxiters = convert(Int, maxiters)
-    end
-
-    f = instantiate_function(prob.f,prob.u0,prob.f.adtype,prob.p,prob.ucons === nothing ? 0 : length(prob.ucons))
-
-    f.cons_j ===nothing && error("Use OptimizationFunction to pass the derivatives or automatically generate them with one of the autodiff backends")
-
-    _loss = function(θ)
-        x = f.f(θ, prob.p, cur...)
-        return x[1]
-    end
-    fg! = function (G,θ)
-        if G !== nothing
-            f.grad(G, θ, cur...)
-        end
-        return _loss(θ)
-    end
-    optim_f = TwiceDifferentiable(_loss, (G, θ) -> f.grad(G, θ, cur...), fg!, (H,θ) -> f.hess(H, θ, cur...), prob.u0)
-
-    cons! = (res, θ) -> res .= f.cons(θ);
-
-    cons_j! = function(J, x)
-        f.cons_j(J, x)
-    end
-
-    cons_hl! = function (h, θ, λ)
-        res = [similar(h) for i in 1:length(λ)]
-        f.cons_h(res, θ)
-        for i in 1:length(λ)
-            h .+= λ[i]*res[i]
-        end
-    end
-
-    lb = prob.lb === nothing ? [] : prob.lb
-    ub = prob.ub === nothing ? [] : prob.ub
-    optim_fc = TwiceDifferentiableConstraints(cons!, cons_j!, cons_hl!, lb, ub, prob.lcons, prob.ucons)
-
-    original = Optim.optimize(optim_f, optim_fc, prob.u0, opt,
-                              !(isnothing(maxiters)) ? Optim.Options(;
-                                extended_trace = true, callback = _cb,
-                                iterations = maxiters, kwargs...) :
-                                Optim.Options(;extended_trace = true,
-                                callback = _cb, kwargs...))
-    SciMLBase.build_solution(prob, opt, original.minimizer,
-                             original.minimum; original=original)
-end
+function __init__()
+    @require Flux="587475ba-b771-5e3f-ad9e-33799f191a9c" include("solve_flux.jl")
 
+    @require Optim="429524aa-4258-5aef-a3af-852621145aeb" include("solve_optim.jl")
 
-function __init__()
     @require BlackBoxOptim="a134a8b2-14d6-55f6-9291-3336d3ab0209" begin
         decompose_trace(opt::BlackBoxOptim.OptRunController) = BlackBoxOptim.best_candidate(opt)