Euclidean tests pass, use riemannian gradient wrapper

Author: Vaibhavdixit02

lib/OptimizationManopt/Project.toml

@@ -4,6 +4,7 @@ authors = ["Mateusz Baran <[email protected]>"]
 version = "0.1.0"
 
 [deps]
+ManifoldDiff = "af67fdf4-a580-4b9f-bbec-742ef357defd"
 Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e"
 ManifoldsBase = "3362f125-f0bb-47a3-aa74-596ffd7ef2fb"
 Manopt = "0fc0a36d-df90-57f3-8f93-d78a9fc72bb5"

lib/OptimizationManopt/src/OptimizationManopt.jl

@@ -1,6 +1,6 @@
 module OptimizationManopt
 
-using Optimization, Manopt, ManifoldsBase
+using Optimization, Manopt, ManifoldsBase, ManifoldDiff
 
 """
     abstract type AbstractManoptOptimizer end
@@ -52,7 +52,7 @@ function call_manopt_optimizer(opt::GradientDescentOptimizer{Teval},
                             stepsize = opt.stepsize,
                             sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = Manopt.get_solver_result(opts)
+    minimizer = opts
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -61,15 +61,12 @@ end
 
 struct NelderMeadOptimizer{
                            TM <: AbstractManifold,
-                           Tpop <: AbstractVector
                            } <: AbstractManoptOptimizer
     M::TM
-    initial_population::Tpop
 end
 
 function NelderMeadOptimizer(M::AbstractManifold)
-    initial_population = [rand(M) for _ in 1:(manifold_dimension(M) + 1)]
-    return NelderMeadOptimizer{typeof(M), typeof(initial_population)}(M, initial_population)
+    return NelderMeadOptimizer{typeof(M)}(M)
 end
 
 function call_manopt_optimizer(opt::NelderMeadOptimizer,
@@ -80,11 +77,10 @@ function call_manopt_optimizer(opt::NelderMeadOptimizer,
     sckwarg = stopping_criterion_to_kwarg(stopping_criterion)
 
     opts = NelderMead(opt.M,
-                      loss,
-                      opt.initial_population;
+                      loss;
                       return_options = true,
                       sckwarg...)
-    minimizer = Manopt.get_solver_result(opts)
+    minimizer = opts
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -123,7 +119,7 @@ function call_manopt_optimizer(opt::ConjugateGradientDescentOptimizer{Teval},
                                       stepsize = opt.stepsize,
                                       sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = Manopt.get_solver_result(opts)
+    minimizer = opts
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -177,7 +173,7 @@ function call_manopt_optimizer(opt::ParticleSwarmOptimizer{Teval},
                           vector_transport_method = opt.vector_transport_method,
                           sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = Manopt.get_solver_result(opts)
+    minimizer = opts
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -229,7 +225,7 @@ function call_manopt_optimizer(opt::QuasiNewtonOptimizer{Teval},
                                       stepsize = opt.stepsize,
                                       sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = Manopt.get_solver_result(opts)
+    minimizer = opts
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -245,14 +241,14 @@ function build_loss(f::OptimizationFunction, prob, cur)
 end
 
 function build_gradF(f::OptimizationFunction{true}, prob, cur)
-    function (M::AbstractManifold, G, θ)
+    function g(M::AbstractManifold, G, θ)
         f.grad(G, θ, cur...)
         G .= riemannian_gradient(M, θ, G)
-        if prob.sense === Optimization.MaxSense
-            return -G # TODO: check
-        else
-            return G
-        end
+    end
+    function g(M::AbstractManifold, θ)
+        G = zero(θ)
+        f.grad(G, θ, cur...)
+        return riemannian_gradient(M, θ, G)
     end
 end
 

lib/OptimizationManopt/test/runtests.jl

@@ -4,7 +4,7 @@ using Manifolds
 using ForwardDiff
 using Manopt
 using Test
-using SciMLBase
+using Optimization.SciMLBase
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 
@@ -17,7 +17,7 @@ R2 = Euclidean(2)
 
 @testset "Gradient descent" begin
     x0 = zeros(2)
-    p = [1.0, 100.0]
+    p = [1.0, 100.0] 
 
     stepsize = Manopt.ArmijoLinesearch(R2)
     opt = OptimizationManopt.GradientDescentOptimizer(R2,
@@ -38,13 +38,13 @@ end
     x0 = zeros(2)
     p = [1.0, 100.0]
 
-    opt = OptimizationManopt.NelderMeadOptimizer(R2, [[1.0, 0.0], [0.0, 1.0], [0.0, 0.0]])
+    opt = OptimizationManopt.NelderMeadOptimizer(R2)
 
     optprob = OptimizationFunction(rosenbrock)
     prob = OptimizationProblem(optprob, x0, p)
 
     sol = Optimization.solve(prob, opt)
-    @test sol.minimum < 0.7
+    @test sol.minimum < 1e-6
 end
 
 @testset "Conjugate gradient descent" begin
@@ -59,7 +59,7 @@ end
     prob = OptimizationProblem(optprob, x0, p)
 
     sol = Optimization.solve(prob, opt)
-    @test sol.minimum < 0.2
+    @test sol.minimum < 0.5
 end
 
 @testset "Quasi Newton" begin
@@ -72,7 +72,7 @@ end
     prob = OptimizationProblem(optprob, x0, p)
 
     sol = Optimization.solve(prob, opt)
-    @test sol.minimum < 1e-16
+    @test sol.minimum < 1e-14
 end
 
 @testset "Particle swarm" begin