Merge pull request #934 from mxpoch/master

added pycma docs and python kwargs

Author: ChrisRackauckas

docs/pages.jl

@@ -23,7 +23,7 @@ pages = ["index.md",
         "API/modelingtoolkit.md",
         "API/FAQ.md"
     ],
-    "Optimizer Packages" => [
+    "Optimizer Packages" => [   
         "BlackBoxOptim.jl" => "optimization_packages/blackboxoptim.md",
         "CMAEvolutionStrategy.jl" => "optimization_packages/cmaevolutionstrategy.md",
         "Evolutionary.jl" => "optimization_packages/evolutionary.md",
@@ -40,6 +40,7 @@ pages = ["index.md",
         "Optimization.jl" => "optimization_packages/optimization.md",
         "Polyalgorithms.jl" => "optimization_packages/polyopt.md",
         "PRIMA.jl" => "optimization_packages/prima.md",
+        "PyCMA.jl" => "optimization_packages/pycma.md",
         "QuadDIRECT.jl" => "optimization_packages/quaddirect.md",
         "SpeedMapping.jl" => "optimization_packages/speedmapping.md",
         "SciPy.jl" => "optimization_packages/scipy.md"

docs/src/optimization_packages/pycma.md

@@ -0,0 +1,63 @@
+# PyCMA.jl
+
+[`PyCMA`](https://github.com/CMA-ES/pycma) is a Python implementation of CMA-ES and a few related numerical optimization tools. `OptimizationPyCMA.jl` gives access to the CMA-ES optimizer through the unified `Optimization.jl` interface just like any native Julia optimizer.
+
+`OptimizationPyCMA.jl` relies on [`PythonCall`](https://github.com/cjdoris/PythonCall.jl). A minimal Python distribution containing PyCMA will be installed automatically on first use, so no manual Python set-up is required.
+
+## Installation: OptimizationPyCMA.jl
+
+```julia
+import Pkg
+Pkg.add("OptimizationPyCMA")
+```
+
+## Methods
+
+`PyCMAOpt` supports the usual keyword arguments `maxiters`, `maxtime`, `abstol`, `reltol` in addition to any PyCMA-specific options (passed verbatim via keyword arguments to `solve`).
+
+## Example
+
+```@example PyCMA
+using OptimizationPyCMA
+
+rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
+x0 = zeros(2)
+_p = [1.0, 100.0]
+l1 = rosenbrock(x0, _p)
+f = OptimizationFunction(rosenbrock)
+prob = OptimizationProblem(f, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
+sol = solve(prob, PyCMAOpt())
+```
+
+## Passing solver-specific options
+
+Any keyword that `Optimization.jl` does not interpret is forwarded directly to PyCMA. 
+
+In the event an `Optimization.jl` keyword overlaps with a `PyCMA` keyword, the `Optimization.jl` keyword takes precedence. 
+
+An exhaustive list of keyword arguments can be found by running the following python script:
+
+```python
+import cma
+options = cma.CMAOptions()
+print(options)
+```
+
+An example passing the `PyCMA` keywords "verbose" and "seed":
+```julia
+sol = solve(prob, PyCMA(), verbose = -9, seed = 42)
+```
+
+## Troubleshooting
+
+The original Python result object is attached to the solution in the `original` field:
+
+```julia
+sol = solve(prob, PyCMAOpt())
+println(sol.original) 
+```
+
+## Contributing
+
+Bug reports and feature requests are welcome in the [Optimization.jl](https://github.com/SciML/Optimization.jl) issue tracker.  Pull requests that improve either the Julia wrapper or the documentation are highly appreciated. 
+

lib/OptimizationPyCMA/src/OptimizationPyCMA.jl

@@ -18,9 +18,9 @@ function get_cma()
 end
 
 # Defining the SciMLBase interface for PyCMAOpt
-
 SciMLBase.allowsbounds(::PyCMAOpt) = true
 SciMLBase.supports_opt_cache_interface(opt::PyCMAOpt) = true
+SciMLBase.allowscallback(::PyCMAOpt) = false
 SciMLBase.requiresgradient(::PyCMAOpt) = false
 SciMLBase.requireshessian(::PyCMAOpt) = false
 SciMLBase.requiresconsjac(::PyCMAOpt) = false
@@ -31,15 +31,26 @@ function __map_optimizer_args(prob::OptimizationCache, opt::PyCMAOpt;
         maxiters::Union{Number, Nothing} = nothing,
         maxtime::Union{Number, Nothing} = nothing,
         abstol::Union{Number, Nothing} = nothing,
-        reltol::Union{Number, Nothing} = nothing)
+        reltol::Union{Number, Nothing} = nothing,
+        PyCMAargs...)
     if !isnothing(reltol)
         @warn "common reltol is currently not used by $(opt)"
     end
+    
+    # Converting Optimization.jl args to PyCMA opts
+    # Optimization.jl kwargs will overwrite PyCMA kwargs supplied to solve() 
 
-    mapped_args = Dict(
-        "verbose" => -5,
-        "bounds" => (prob.lb, prob.ub),
-        )
+    mapped_args = Dict{String, Any}()
+
+    # adding PyCMA args
+    merge!(mapped_args, Dict(string(k) => v for (k, v) in PyCMAargs))
+    
+    # mapping Optimization.jl args
+    mapped_args["bounds"] = (prob.lb, prob.ub)
+    
+    if !("verbose" ∈ keys(mapped_args))
+        mapped_args["verbose"] = -1   
+    end 
 
     if !isnothing(abstol)
         mapped_args["tolfun"] = abstol
@@ -111,15 +122,15 @@ function SciMLBase.__solve(cache::OptimizationCache{
 
     # wrapping the objective function
     _loss = function (θ)
-        x = cache.f(θ, cache.p)
+        x = cache.f(θ, cache.p)    
         return first(x)
     end
 
     # converting the Optimization.jl Args to PyCMA format
     opt_args = __map_optimizer_args(cache, cache.opt; cache.solver_args...,
         maxiters = maxiters,
         maxtime = maxtime)
-    
+
     # init the CMAopt class
     es = get_cma().CMAEvolutionStrategy(cache.u0, 1, pydict(opt_args))
     logger = es.logger

lib/OptimizationPyCMA/test/runtests.jl

@@ -1,5 +1,4 @@
-using OptimizationPyCMA
-using Test
+using OptimizationPyCMA, Test
 
 @testset "OptimizationPyCMA.jl" begin
     rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
@@ -9,6 +8,6 @@ using Test
     f = OptimizationFunction(rosenbrock)
     prob = OptimizationProblem(f, x0, _p, lb = [-1.0, -1.0], ub = [0.8, 0.8])
     sol = solve(prob, PyCMAOpt())
-    @test 10 * sol.objective < l1
-    sol = solve(prob, PyCMAOpt(), maxiters = 100)
+    @test 10 * sol.objective < l1    
+    sol = solve(prob, PyCMAOpt(), maxiters = 100, verbose=-1, seed=42)
 end