add initial stepsize guess to the LineSearches wrapper, rename a function, disable the I0 (a) heuristic by default.

Author: mateuszbaran

ext/ManoptLineSearchesExt.jl

@@ -22,7 +22,7 @@ function (cs::Manopt.LineSearchesStepsize)(
     dphi_0 = get_differential(mp, p, η; Y = X_tmp)
 
     # guess initial alpha
-    α0 = 1.0
+    α0 = cs.initial_guess(mp, s, k, cs.last_stepsize, η; lf0 = fp, Dlf0 = dphi_0)
 
     # perform actual line-search
 
@@ -42,6 +42,7 @@ function (cs::Manopt.LineSearchesStepsize)(
     end
 
     α, fp = cs.linesearch(ϕ, dϕ, ϕdϕ, α0, fp, dphi_0)
+    cs.last_stepsize = α
     return α
 end
 

ext/ManoptManifoldsExt/manifold_functions.jl

@@ -1,5 +1,10 @@
+"""
+    default_point_distance(::DefaultManifold, p)
 
-Manopt.default_point_norm(::Euclidean, p) = norm(p, Inf)
+Following [HagerZhang:2006:2](@cite), the expected distance to the optimal solution from `p`
+on `DefaultManifold` is the `Inf` norm of `p`.
+"""
+Manopt.default_point_distance(::Euclidean, p) = norm(p, Inf)
 
 Manopt.default_vector_norm(::Euclidean, p, X) = norm(p, Inf)
 

src/helpers/LineSearchesTypes.jl

@@ -21,42 +21,50 @@ The initial step selection from Linesearches.jl is not yet supported and the val
 $(_var(:Keyword, :retraction_method))
 $(_var(:Keyword, :vector_transport_method))
 """
-struct LineSearchesStepsize{
-        TLS, TRM <: AbstractRetractionMethod, TVTM <: AbstractVectorTransportMethod,
+mutable struct LineSearchesStepsize{
+        TLS, TIG <: AbstractInitialLinesearchGuess, TRM <: AbstractRetractionMethod, TVTM <: AbstractVectorTransportMethod, TF <: Real,
     } <: Stepsize
     linesearch::TLS
+    initial_guess::TIG
     retraction_method::TRM
     vector_transport_method::TVTM
+    last_stepsize::TF
 end
 function LineSearchesStepsize(
         M::AbstractManifold,
         linesearch;
+        initial_guess::AbstractInitialLinesearchGuess = ConstantInitialGuess(),
         retraction_method::AbstractRetractionMethod = default_retraction_method(M),
         vector_transport_method::AbstractVectorTransportMethod = default_vector_transport_method(
             M
         ),
+        last_stepsize::Real = NaN,
     )
     return LineSearchesStepsize(
         linesearch;
+        initial_guess = initial_guess,
         retraction_method = retraction_method,
         vector_transport_method = vector_transport_method,
+        last_stepsize = last_stepsize
     )
 end
 function LineSearchesStepsize(
         linesearch;
+        initial_guess::AbstractInitialLinesearchGuess = ConstantInitialGuess(),
         retraction_method::AbstractRetractionMethod = ExponentialRetraction(),
         vector_transport_method::AbstractVectorTransportMethod = ParallelTransport(),
+        last_stepsize::Real = NaN,
     )
     return LineSearchesStepsize{
-        typeof(linesearch), typeof(retraction_method), typeof(vector_transport_method),
+        typeof(linesearch), typeof(initial_guess), typeof(retraction_method), typeof(vector_transport_method), typeof(last_stepsize),
     }(
-        linesearch, retraction_method, vector_transport_method
+        linesearch, initial_guess, retraction_method, vector_transport_method, last_stepsize
     )
 end
 
 function Base.show(io::IO, cs::LineSearchesStepsize)
     return print(
         io,
-        "LineSearchesStepsize($(cs.linesearch); retraction_method=$(cs.retraction_method), vector_transport_method=$(cs.vector_transport_method))",
+        "LineSearchesStepsize($(cs.linesearch); initial_guess=$(cs.initial_guess), retraction_method=$(cs.retraction_method), vector_transport_method=$(cs.vector_transport_method), last_stepsize=$(cs.last_stepsize))",
     )
 end

src/plans/stepsize/initial_guess.jl

@@ -1,5 +1,17 @@
 abstract type AbstractInitialLinesearchGuess end
 
+struct ConstantInitialGuess{TF} <: AbstractInitialLinesearchGuess
+    α::TF
+end
+ConstantInitialGuess() = ConstantInitialGuess(1.0)
+
+function (cig::ConstantInitialGuess)(
+        mp::AbstractManoptProblem, s::AbstractManoptSolverState, ::Int, l::Real, η; kwargs...
+    )
+    return cig.α
+end
+
+
 struct ArmijoInitialGuess <: AbstractInitialLinesearchGuess end
 
 """
@@ -49,10 +61,31 @@ _doc_stepsize_initial_guess(default = "") = """
 
 """
 
-default_point_norm(::AbstractManifold, p) = one(number_eltype(p))
-default_point_norm(::DefaultManifold, p) = norm(p, Inf)
+"""
+    default_point_distance(::AbstractManifold, p)
 
-default_vector_norm(M::AbstractManifold, p, X) = norm(M, p, X)
+The default Hager-Zhang guess for distance between `p` the solution to the optimization
+problem. The default is 0, which deactivates heuristic I0 (a).
+On each manifold with `default_point_distance`, you need to also implement `default_vector_norm`.
+"""
+default_point_distance(::AbstractManifold, p) = zero(number_eltype(p))
+
+"""
+    default_point_distance(::DefaultManifold, p)
+
+Following [HagerZhang:2006:2](@cite), the expected distance to the optimal solution from `p`
+on `DefaultManifold` is the `Inf` norm of `p`.
+"""
+default_point_distance(::DefaultManifold, p) = norm(p, Inf)
+
+"""
+    default_point_distance(::AbstractManifold, p)
+
+The default Hager-Zhang guess for distance between `p` the solution to the optimization
+problem along the descent direction. There is no default implementation because it is only
+needed for manifolds with a specific `default_point_distance` method.
+"""
+default_vector_norm(M::AbstractManifold, p, X)
 default_vector_norm(::DefaultManifold, p, X) = norm(p, Inf)
 
 
@@ -69,7 +102,7 @@ struct HagerZhangInitialGuess{TF <: Real, TPN, TVN} <: AbstractInitialLinesearch
     ψ2::TF
     constant_guess::TF
     quadstep::Bool
-    point_norm::TPN
+    point_distance::TPN
     vector_norm::TVN
     zero_abstol::TF
     alphamax::TF
@@ -82,14 +115,14 @@ function HagerZhangInitialGuess{TF}(;
         ψ2::TF = 2.0,
         constant_guess::TF = NaN,
         quadstep::Bool = true,
-        point_norm::TPN = default_point_norm,
+        point_distance::TPN = default_point_distance,
         vector_norm::TVN = default_vector_norm,
         zero_abstol::TF = eps(TF),
         alphamax::TF = Inf,
     ) where {TF <: Real, TPN, TVN}
     return HagerZhangInitialGuess{TF, TPN, TVN}(
         ψ0, ψ1, ψ2, constant_guess, quadstep,
-        point_norm, vector_norm, zero_abstol, alphamax
+        point_distance, vector_norm, zero_abstol, alphamax
     )
 end
 
@@ -106,12 +139,12 @@ function (hzi::HagerZhangInitialGuess{TF})(
     alphamax = min(hzi.alphamax, max_stepsize(M, p))
 
     if k == 1
-        pn = hzi.point_norm(M, p)
-        ηn = hzi.vector_norm(M, p, η)
+        pn = hzi.point_distance(M, p)
         # Step I0
         if isnan(hzi.constant_guess)
             if pn > hzi.zero_abstol
                 # I0.(a)
+                ηn = hzi.vector_norm(M, p, η)
                 return min(hzi.ψ0 * pn / ηn, alphamax)
             elseif abs_lf0 > hzi.zero_abstol
                 # I0.(b)

test/plans/test_stepsize.jl

@@ -21,7 +21,7 @@ using ManoptTestSuite
 
         gds1 = GradientDescentState(M; p = p1)
         η1 = -X1
-        @test hzi(dmp, gds1, 1, NaN, η1) ≈ hzi.ψ0 * Manopt.default_point_norm(M, p1) / Manopt.default_vector_norm(M, p1, η1)
+        @test hzi(dmp, gds1, 1, NaN, η1) ≈ hzi.ψ0 * Manopt.default_point_distance(M, p1) / Manopt.default_vector_norm(M, p1, η1)
         # case I0 (b)
         p2 = [0.0, 0.0]
         X2 = grad_f(M, p2)
@@ -61,7 +61,7 @@ using ManoptTestSuite
 
         gds = GradientDescentState(MS; p = p4)
         η4 = -X4
-        @test hzi(dmp, gds, 1, NaN, η4) ≈ 5.0e-5
+        @test hzi(dmp, gds, 1, NaN, η4) ≈ 2.5e-5
     end
 end