Merge pull request #110 from SciML/mtk

Further integrate and document ModelingToolkit

Author: ChrisRackauckas

Project.toml

@@ -1,7 +1,7 @@
 name = "GalacticOptim"
 uuid = "a75be94c-b780-496d-a8a9-0878b188d577"
 authors = ["Vaibhavdixit02 <[email protected]>"]
-version = "0.4.6"
+version = "0.4.7"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
@@ -13,6 +13,7 @@ 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"
@@ -32,6 +33,7 @@ FiniteDiff = "2.5"
 Flux = "0.11"
 ForwardDiff = "0.10"
 LoggingExtras = "0.4"
+ModelingToolkit = "5.2.1"
 Optim = "1"
 ProgressLogging = "0.1"
 Reexport = "0.2, 1.0"
@@ -43,7 +45,6 @@ Zygote = "0.5, 0.6"
 julia = "1.5"
 
 [extras]
-BlackBoxOptim = "a134a8b2-14d6-55f6-9291-3336d3ab0209"
 CMAEvolutionStrategy = "8d3b24bd-414e-49e0-94fb-163cc3a3e411"
 DiffEqFlux = "aae7a2af-3d4f-5e19-a356-7da93b79d9d0"
 Evolutionary = "86b6b26d-c046-49b6-aa0b-5f0f74682bd6"
@@ -56,4 +57,4 @@ 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 = ["Evolutionary", "DiffEqFlux", "IterTools", "OrdinaryDiffEq", "NLopt", "CMAEvolutionStrategy", "Pkg", "Random", "SafeTestsets", "Test"]

docs/Project.toml

@@ -2,4 +2,4 @@
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [compat]
-Documenter = "0.25.3"
+Documenter = "0.26"

docs/make.jl

@@ -22,7 +22,8 @@ makedocs(
         "API" => [
             "OptimizationProblem" => "API/optimization_problem.md",
             "OptimizationFunction" => "API/optimization_function.md",
-            "solve" => "API/solve.md"
+            "solve" => "API/solve.md",
+            "ModelingToolkit Integration" => "API/modelingtoolkit.md"
         ],
 
         "Local Optimizers" => [
@@ -31,7 +32,7 @@ makedocs(
             "local_optimizers/local_hessian.md",
             "local_optimizers/local_hessian_free.md"
         ],
-        
+
         "Global Optimizers" => [
             "global_optimizers/global.md",
             "global_optimizers/global_constrained.md"

docs/src/API/modelingtoolkit.md

@@ -0,0 +1,19 @@
+# ModelingToolkit Integration
+
+GalacticOptim.jl is heavily integrated with the ModelingToolkit.jl
+symbolic system for symbolic-numeric optimizations. It provides a
+front-end for automating the construction, parallelization, and
+optimization of code. Optimizers can better interface with the extra
+symbolic information provided by the system.
+
+There are two ways that the user interacts with ModelingToolkit.jl.
+One can use `OptimizationFunction` with `AutoModelingToolkit` for
+automatically transforming numerical codes into symbolic codes. See
+the [OptimizationFunction documentation](@id optfunction) for more
+details.
+
+Secondly, one can generate `OptimizationProblem`s for use in
+GalacticOptim.jl from purely a symbolic front-end. This is the form
+users will encounter when using ModelingToolkit.jl directly, and its
+also the form supplied by domain-specific languages. For more information,
+see the [OptimizationSystem documentation](https://mtk.sciml.ai/dev/systems/OptimizationSystem/).

docs/src/API/optimization_function.md

@@ -126,13 +126,31 @@ This uses the [ModelingToolkit.jl](https://github.com/SciML/ModelingToolkit.jl)
 symbolic system for automatically converting the `f` function into
 a symbolic equation and uses symbolic differentiation in order to generate
 a fast derivative code. Note that this will also compile a new version
-of your `f` function that is automatically optimized. In this choice,
-it defaults to `grad=false` and `hess=false`, and one must change these
-to `true` in order to enable the symbolic derivation. Future updates
-will enable automatic parallelization and sparsity in the derived
-functions. This can be the fastest for many systems, especially when
-parallelization and sparsity are required, but can take the longest
-to generate.
+of your `f` function that is automatically optimized. Because of the
+required symbolic analysis, the state and parameters are required in
+the function definition, i.e.:
+
+```julia
+OptimizationFunction(f,AutoModelingToolkit(),x0,p,
+                     grad = false, hess = false, sparse = false,
+                     checkbounds = false,
+                     linenumbers = true,
+                     parallel=SerialForm(),
+                     kwargs...)
+```
+
+The special keyword arguments are as follows:
+
+- `grad`: whether to symbolically generate the gradient function.
+- `hess`: whether to symbolically generate the Hessian function.
+- `sparse`: whether to use sparsity detection in the Hessian.
+- `checkbounds`: whether to perform bounds checks in the generated code.
+- `linenumbers`: whether to include line numbers in the generated code.
+- `parallel`: whether to automatically parallelize the calculations.
+
+For more information, see the [ModelingToolkit.jl `OptimizationSystem` documentation](https://mtk.sciml.ai/dev/systems/OptimizationSystem/)
+
+Summary:
 
 - Not compatible with GPUs
 - Compatible with Hessian-based optimization

docs/src/tutorials/symbolic.md

@@ -0,0 +1,28 @@
+# Symbolic Problem Building with ModelingToolkit
+
+```julia
+using ModelingToolkit, GalacticOptim
+
+@variables x y
+@parameters a b
+loss = (a - x)^2 + b * (y - x^2)^2
+sys = OptimizationSystem(loss,[x,y],[a,b])
+
+u0 = [
+    x=>1.0
+    y=>2.0
+]
+p = [
+    a => 6.0
+    b => 7.0
+]
+
+prob = OptimizationProblem(sys,u0,p,grad=true,hess=true)
+solve(prob,Newton())
+```
+
+Needs text but it's super cool and auto-parallelizes and sparsifies too.
+Plus you can hierarchically nest systems to have it generate huge
+optimization problems. Check out the
+[ModelingToolkit.jl OptimizationSystem documentation](https://mtk.sciml.ai/dev/systems/OptimizationSystem/)
+for more information.

src/GalacticOptim.jl

@@ -11,6 +11,10 @@ using ArrayInterface, Base.Iterators
 using ForwardDiff: DEFAULT_CHUNK_THRESHOLD
 import DiffEqBase: OptimizationProblem, OptimizationFunction, AbstractADType
 
+import ModelingToolkit
+import ModelingToolkit: AutoModelingToolkit
+export AutoModelingToolkit
+
 include("solve.jl")
 include("function.jl")
 

test/rosenbrock.jl

@@ -110,11 +110,22 @@ using Evolutionary
 sol = solve(prob, CMAES(μ =40 , λ = 100),abstol=1e-15)
 @test 10*sol.minimum < l1
 
+#=
 using BlackBoxOptim
 prob = GalacticOptim.OptimizationProblem(optprob, x0, lb=[-1.0, -1.0], ub=[0.8, 0.8])
 sol = solve(prob, BBO())
 @test 10*sol.minimum < l1
 
 prob_multi = EnsembleOptimizationProblem([prob, prob])
 sol_multi = solve(prob_multi, BBO(:borg_moea), FitnessScheme=ParetoFitnessScheme{2}(is_minimizing=true), ϵ=0.05, MaxSteps=500000)
-@test 10*sum(sol_multi.minimum) < l1
+@test 10*sum(sol_multi.minimum) < l1
+=#
+
+using ModelingToolkit
+rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
+x0 = zeros(2)
+_p = [1.0, 100.0]
+
+f = OptimizationFunction(rosenbrock,ModelingToolkit.AutoModelingToolkit(),x0,_p,grad=true,hess=true)
+prob = OptimizationProblem(f,x0,_p)
+sol = solve(prob,Optim.Newton())