fixes, more on AbsManiMin

Author: dehann

NEWS.md

@@ -11,6 +11,14 @@ Alternatively, either use the Github Blame, or the Github `/compare/v0.18.0...v0
 
 The list below highlights breaking changes according to normal semver workflow -- i.e. breaking changes go through at least one deprecatation (via warnings) on the dominant number in the version number.  E.g. v0.18 -> v0.19 (warnings) -> v0.20 (breaking).  Note that ongoing efforts are made to properly deprecate old code/APIs
 
+# Changes in v0.34
+
+- Start transition to Manopt.jl via Riemannian Levenberg Marquart.
+- Deprecate `AbstractRelativeRoots`.
+
+# Changes in v0.33
+
+- Upgrades for DFG using StructTypes.jl (serialization).
 # Changes in v0.32
 
 - Major internal refactoring of `CommonConvWrapper` to avoid abstract field types, and better standardization; towards cleanup of internal multihypo handling and naming conventions.

src/Deprecated.jl

@@ -119,6 +119,29 @@ function solveGraphParametric2(
   return d, result, flatvar.idx, Σ
 end
 
+
+##==============================================================================
+## Deprecate code below before v0.35
+##==============================================================================
+
+
+
+function _solveLambdaNumeric(
+  fcttype::Union{F, <:Mixture{N_, F, S, T}},
+  objResX::Function,
+  residual::AbstractVector{<:Real},
+  u0::AbstractVector{<:Real},
+  islen1::Bool = false,
+) where {N_, F <: AbstractRelativeRoots, S, T}
+  #
+
+  #
+  r = NLsolve.nlsolve((res, x) -> res .= objResX(x), u0; inplace = true) #, ftol=1e-14)
+
+  #
+  return r.zero
+end
+
 ##==============================================================================
 ## Deprecate code below before v0.35
 ##==============================================================================

src/Factors/EuclidDistance.jl

@@ -6,7 +6,7 @@ $(TYPEDEF)
 
 Default linear offset between two scalar variables.
 """
-struct EuclidDistance{T <: SamplableBelief} <: AbstractRelativeMinimize
+struct EuclidDistance{T <: SamplableBelief} <: AbstractManifoldMinimize # AbstractRelativeMinimize
   Z::T
 end
 

src/Factors/GenericFunctions.jl

@@ -69,8 +69,10 @@ export ManifoldFactor
 # For now, `Z` is on the tangent space in coordinates at the point used in the factor.
 # For groups just the lie algebra
 # As transition it will be easier this way, we can reevaluate
-struct ManifoldFactor{M <: AbstractManifold, T <: SamplableBelief} <:
-       AbstractManifoldMinimize #AbstractFactor
+struct ManifoldFactor{
+  M <: AbstractManifold, 
+  T <: SamplableBelief
+} <: AbstractManifoldMinimize
   M::M
   Z::T
 end

src/Factors/GenericMarginal.jl

@@ -3,7 +3,7 @@
 """
 $(TYPEDEF)
 """
-mutable struct GenericMarginal <: AbstractRelativeRoots
+mutable struct GenericMarginal <: AbstractManifoldMinimize # AbstractRelativeRoots
   Zij::Array{Float64, 1}
   Cov::Array{Float64, 1}
   W::Array{Float64, 1}

src/Factors/LinearRelative.jl

@@ -10,7 +10,7 @@ Default linear offset between two scalar variables.
 X_2 = X_1 + η_Z
 ```
 """
-struct LinearRelative{N, T <: SamplableBelief} <: AbstractRelativeMinimize
+struct LinearRelative{N, T <: SamplableBelief} <: AbstractManifoldMinimize # AbstractRelativeMinimize
   Z::T
 end
 

src/ParametricUtils.jl

@@ -515,6 +515,7 @@ end
 
 function solveGraphParametric(
   fg::AbstractDFG;
+  verbose::Bool = false,
   computeCovariance::Bool = true,
   solveKey::Symbol = :parametric,
   autodiff = :forward,
@@ -571,6 +572,8 @@ function solveGraphParametric(
   tdtotalCost = Optim.TwiceDifferentiable(gsc, initValues; autodiff = autodiff)
 
   result = Optim.optimize(tdtotalCost, initValues, alg, options)
+  !verbose ? nothing : @show(result)
+
   rv = Optim.minimizer(result)
 
   # optionally compute hessian for covariance
@@ -827,6 +830,7 @@ function DFG.solveGraphParametric!(
   init::Bool = true, 
   solveKey::Symbol = :parametric, # FIXME, moot since only :parametric used for parametric solves
   initSolveKey::Symbol = :default, 
+  verbose = false,
   kwargs...
 )
   # make sure variables has solverData, see #1637
@@ -837,7 +841,7 @@ function DFG.solveGraphParametric!(
     initParametricFrom!(fg, initSolveKey; parkey=solveKey)
   end
 
-  vardict, result, varIds, Σ = solveGraphParametric(fg; kwargs...)
+  vardict, result, varIds, Σ = solveGraphParametric(fg; verbose, kwargs...)
 
   updateParametricSolution!(fg, vardict)
 

src/services/DeconvUtils.jl

@@ -79,28 +79,34 @@ function approxDeconv(
     target_smpl = makeTarget(idx)
 
     # TODO must first resolve hypothesis selection before unrolling them -- deferred #1096
-    resize!(ccw.activehypo, length(hyporecipe.activehypo[2][2]))
-    ccw.activehypo[:] = hyporecipe.activehypo[2][2]
+    resize!(ccw.hyporecipe.activehypo, length(hyporecipe.activehypo[2][2]))
+    ccw.hyporecipe.activehypo[:] = hyporecipe.activehypo[2][2]
 
     onehypo!, _ = _buildCalcFactorLambdaSample(ccw, idx, target_smpl, measurement)
     #
 
     # lambda with which to find best measurement values
-    hypoObj = (tgt) -> (target_smpl .= tgt; onehypo!())
+    function hypoObj(tgt)
+      copyto!(target_smpl, tgt)
+      return onehypo!()
+    end
+    # hypoObj = (tgt) -> (target_smpl .= tgt; onehypo!())
 
     # find solution via SubArray view pointing to original memory location
     if fcttype isa AbstractManifoldMinimize
       sfidx = ccw.varidx[]
-      target_smpl .= _solveLambdaNumericMeas(
+      ts = _solveLambdaNumericMeas(
         fcttype,
         hypoObj,
         res_,
         measurement[idx],
         getVariableType(ccw.fullvariables[sfidx]), # ccw.vartypes[sfidx](),
         islen1,
       )
+      copyto!(target_smpl, ts) 
     else
-      target_smpl .= _solveLambdaNumeric(fcttype, hypoObj, res_, measurement[idx], islen1)
+      ts = _solveLambdaNumeric(fcttype, hypoObj, res_, measurement[idx], islen1)
+      copyto!(target_smpl, ts)
     end
   end
 

src/services/NumericalCalculations.jl

@@ -69,21 +69,6 @@ function _solveLambdaNumeric(
 end
 #
 
-function _solveLambdaNumeric(
-  fcttype::Union{F, <:Mixture{N_, F, S, T}},
-  objResX::Function,
-  residual::AbstractVector{<:Real},
-  u0::AbstractVector{<:Real},
-  islen1::Bool = false,
-) where {N_, F <: AbstractRelativeRoots, S, T}
-  #
-
-  #
-  r = NLsolve.nlsolve((res, x) -> res .= objResX(x), u0; inplace = true) #, ftol=1e-14)
-
-  #
-  return r.zero
-end
 
 function _solveLambdaNumeric(
   fcttype::Union{F, <:Mixture{N_, F, S, T}},
@@ -304,7 +289,6 @@ _getusrfnc(ccwl::CommonConvWrapper{<:Mixture}) = ccwl.usrfnc!.mechanics
 function _buildCalcFactor(
   ccwl::CommonConvWrapper,
   smpid,
-  # measurement_, # deprecate
   varParams,
   activehypo,
 )
@@ -335,7 +319,6 @@ DevNotes
 - TODO refactor relationship and common fields between (CCW, FMd, CPT, CalcFactor)
 """
 function _buildCalcFactorLambdaSample(
-  # destVarVals::AbstractVector,
   ccwl::CommonConvWrapper,
   smpid::Integer,
   target, # partials no longer on coordinates at this level # = view(destVarVals[smpid], ccwl.partialDims), # target = view(ccwl.varValsAll[ccwl.varidx[]][smpid], ccwl.partialDims),
@@ -350,25 +333,9 @@ function _buildCalcFactorLambdaSample(
 
   # build a view to the decision variable memory
   varValsHypo = ccwl.varValsAll[][ccwl.hyporecipe.activehypo]
-  # tup = tuple(varParams...)
-  # nms = keys(ccwl.varValsAll[])[cpt_.activehypo]
-  # varValsHypo = NamedTuple{nms,typeof(tup)}(tup)
-
-  # prepare fmd according to hypo selection
-  # FIXME must refactor (memory waste) and consolidate with CCW CPT FMd CF
-  # FIXME move up out of smpid loop and only update bare minimal fields
-  # _fmd_ = FactorMetadata( view(fmd_.fullvariables, cpt_.activehypo), 
-  #                         view(fmd_.variablelist, cpt_.activehypo),
-  #                         varValsHypo, #varParams, # view(fmd_.arrRef, cpt_.activehypo),
-  #                         fmd_.solvefor,
-  #                         fmd_.cachedata  )
-  #
+
   # get the operational CalcFactor object
   cf = _buildCalcFactor(ccwl, smpid, varValsHypo, ccwl.hyporecipe.activehypo)
-  # new dev work on CalcFactor
-  # cf = CalcFactor(ccwl.usrfnc!, _fmd_, smpid, 
-  #                 varValsHypo)
-  #
 
   # reset the residual vector
   fill!(ccwl.res, 0.0) # Roots->xDim | Minimize->zDim
@@ -414,11 +381,9 @@ DevNotes
 - TODO perhaps consolidate perturbation with inflation or nullhypo
 """
 function _solveCCWNumeric!(
-  # destVarVals::AbstractVector,
-  ccwl::Union{CommonConvWrapper{F}, CommonConvWrapper{Mixture{N_, F, S, T}}},
+  ccwl::Union{<:CommonConvWrapper{F}, <:CommonConvWrapper{<:Mixture{N_, F, S, T}}},
   _slack = nothing;
   perturb::Real = 1e-10,
-  # testshuffle::Bool=false,
 ) where {N_, F <: AbstractRelative, S, T}
   #
 
@@ -504,19 +469,14 @@ end
 #
 
 function _solveCCWNumeric!(
-  # destVarVals::AbstractVector,
-  ccwl::Union{CommonConvWrapper{F}, CommonConvWrapper{Mixture{N_, F, S, T}}},
+  ccwl::Union{<:CommonConvWrapper{F}, <:CommonConvWrapper{<:Mixture{N_, F, S, T}}},
   _slack = nothing;
   perturb::Real = 1e-10,
-  # testshuffle::Bool=false,
 ) where {N_, F <: AbstractManifoldMinimize, S, T}
   #
   #   # FIXME, move this check higher and out of smpid loop
   # _checkErrorCCWNumerics(ccwl, testshuffle)
 
-  #
-  # thrid = Threads.threadid()
-
   smpid = ccwl.particleidx[]
   # cannot Nelder-Mead on 1dim, partial can be 1dim or more but being conservative.
   islen1 = length(ccwl.partialDims) == 1 || ccwl.partial
@@ -541,8 +501,7 @@ function _solveCCWNumeric!(
   end
 
   # TODO small off-manifold perturbation is a numerical workaround only, make on-manifold requires RoME.jl #244
-  # use all element dimensions : ==> 1:ccwl.xDim
-  # F <: AbstractRelativeRoots && (target .+= _perturbIfNecessary(getFactorType(ccwl), length(target), perturb))
+  # _perturbIfNecessary(getFactorType(ccwl), length(target), perturb)
 
   # do the parameter search over defined decision variables using Minimization
   sfidx = ccwl.varidx[]
@@ -556,14 +515,9 @@ function _solveCCWNumeric!(
     islen1,
   )
 
-  # Check for NaNs
-  # FIXME isnan for manifold ProductRepr
-  # if sum(isnan.(retval)) != 0
-  # @error "$(ccwl.usrfnc!), ccw.thrid_=$(thrid), got NaN, smpid = $(smpid), r=$(retval)\n"
-  # return nothing
-  # end
+  # TBD Check for NaNs
 
-  # FIXME insert result back at the correct variable element location
+  # NOTE insert result back at the correct variable element location
   ccwl.varValsAll[][ccwl.varidx[]][smpid] = retval
 
   return nothing

test/testSpecialOrthogonalMani.jl

@@ -126,7 +126,8 @@ vnd = getVariableSolverData(fg, :x1)
 # 23Q2 default HagerZhang fails with `AssertionError: isfinite(phi_c) && isfinite(dphi_c)`, using alternate LineSearch
 IIF.solveGraphParametric!(
   fg;
-  algorithmkwargs=(;alphaguess = LineSearches.InitialStatic(), linesearch = LineSearches.MoreThuente())
+  algorithmkwargs=(;alphaguess = LineSearches.InitialStatic(), linesearch = LineSearches.MoreThuente()),
+  verbose=true
 )
 
 ##