Autodiff

The manif package differentiates Jacobians with respect to a local perturbation on the tangent space. These Jacobians map tangent spaces, as described in this paper.

However, many non-linear solvers (e.g. Ceres) expect functions to be differentiated with respect to the underlying representation vector of the group element (e.g. with respect to quaternion vector for SO3).

For this reason manif is compliant with the autodiff::dual auto-differentiation type.

For reference of the size of the Jacobians returned when using autodiff::dual, manif implements rotations in the following way:

  • SO(2) and SE(2): as a complex number with real = cos(theta) and imag = sin(theta) values.
  • SO(3), SE(3) and SE_2(3): as a unit quaternion, using the underlying Eigen::Quaternion type.

Therefore, the respective Jacobian sizes using autodiff::dual are as follows:

  • ℝ(n) : size n
  • SO(2) : size 2
  • SO(3) : size 4
  • SE(2) : size 4
  • SE(3) : size 7
  • SE_2(3): size 10

Jacobians

Considering,

Image

a group element (e.g. S3),

Image

the vector tangent to the group at

Image

,

Image

an error function,

one is interested in expressing the Taylor series of the error function,

Image

Therefore we have to compute the Jacobian

Image

the Jacobian of

Image

with respect to a perturbation on the tangent space, so that the state update happens on the manifold tangent space.

In some optimization frameworks, the computation of this Jacobian is decoupled in two folds as explained hereafter.

Using the autodiff library, a cost function can very easily designed as follows,

// functor to be evaluated
auto fun = [](const auto& measurement, const auto& state_i, const auto& state_j){
  return measurement - (state_j - state_i);
};

where state_i & state_j belong to a group and measurement belongs to the group's tangent.

Evaluating the function and its Jacobians is then,

using namespace autodiff;
Eigen::MatrixXd J_e_xi = jacobian(fun, wrt(xi), at(meas_ij, xi, xj), e);
Eigen::MatrixXd J_e_xj = jacobian(fun, wrt(xj), at(meas_ij, xi, xj), e);

It produces Jacobians of the form,

Image

We thus then need to compute the Jacobian that will map to the tangent space - often called local-parameterization. A convenience function is provided in manif to do so as follow:

Eigen::MatrixXd J_xi_lp = autodiffLocalParameterizationJacobian<dual>(xi);
Eigen::MatrixXd J_xj_lp = autodiffLocalParameterizationJacobian<dual>(xj);

This function computes the

Image

operation's Jacobian evaluated for

Image

thus providing the Jacobian,

Image

Once both the cost function and local-parameterization's Jacobians are evaluated, they can be compose as,

Image

Voila.

The intermediate Jacobians (2-3) that some solver requires are not available in manif since the library provides directly the final Jacobian (1).

However, manif is compliant with autodiff::dual auto-differentiation type to compute (2-3).