Loading...
Searching...
No Matches
gtsam::HessianFactor Class Reference

## Detailed Description

A Gaussian factor using the canonical parameters (information form).

HessianFactor implements a general quadratic factor of the form

\[ E(x) = 0.5 x^T G x - x^T g + 0.5 f \]

that stores the matrix \( G \), the vector \( g \), and the constant term \( f \).

When \( G \) is positive semidefinite, this factor represents a Gaussian, in which case \( G \) is the information matrix \( \Lambda \), \( g \) is the information vector \( \eta \), and \( f \) is the residual sum-square-error at the mean, when \( x = \mu \).

Indeed, the negative log-likelihood of a Gaussian is (up to a constant) \( E(x) = 0.5(x-\mu)^T P^{-1} (x-\mu) \) with \( \mu \) the mean and \( P \) the covariance matrix. Expanding the product we get

\[E(x) = 0.5 x^T P^{-1} x - x^T P^{-1} \mu + 0.5 \mu^T P^{-1} \mu \]

We define the Information matrix (or Hessian) \( \Lambda = P^{-1} \) and the information vector \( \eta = P^{-1} \mu = \Lambda \mu \) to arrive at the canonical form of the Gaussian:

\[E(x) = 0.5 x^T \Lambda x - x^T \eta + 0.5 \mu^T \Lambda \mu \]

This factor is one of the factors that can be in a GaussianFactorGraph. It may be returned from NonlinearFactor::linearize(), but is also used internally to store the Hessian during Cholesky elimination.

This can represent a quadratic factor with characteristics that cannot be represented using a JacobianFactor (which has the form \( E(x) = \Vert Ax - b \Vert^2 \) and stores the Jacobian \( A \) and error vector \( b \), i.e. is a sum-of-squares factor). For example, a HessianFactor need not be positive semidefinite, it can be indefinite or even negative semidefinite.

If a HessianFactor is indefinite or negative semi-definite, then in order for solving the linear system to be possible, the Hessian of the full system must be positive definite (i.e. when all small Hessians are combined, the result must be positive definite). If this is not the case, an error will occur during elimination.

This class stores G, g, and f as an augmented matrix HessianFactor::matrix_. The upper-left n x n blocks of HessianFactor::matrix_ store the upper-right triangle of G, the upper-right-most column of length n of HessianFactor::matrix_ stores g, and the lower-right entry of HessianFactor::matrix_ stores f, i.e.

HessianFactor::matrix_ = [ G11 G12 G13 ... g1
0 G22 G23 ... g2
0 0 G33 ... g3
: : : :
0 0 0 ... f ]

Blocks can be accessed as follows:

G11 = info(begin(), begin());
G12 = info(begin(), begin()+1);
G23 = info(begin()+1, begin()+2);
g2 = linearTerm(begin()+1);
f = constantTerm();
.......
gtsam::Factor::begin
const_iterator begin() const
Iterator at beginning of involved variable keys.
Definition Factor.h:143
gtsam::HessianFactor::info
const SymmetricBlockMatrix & info() const
Return underlying information matrix.
Definition HessianFactor.h:265
gtsam::HessianFactor::constantTerm
double constantTerm() const
Return the constant term as described above.
Definition HessianFactor.h:230
gtsam::HessianFactor::linearTerm
SymmetricBlockMatrix::constBlock linearTerm() const
Return the complete linear term as described above.
Definition HessianFactor.h:251
Inheritance diagram for gtsam::HessianFactor:

## Public Member Functions

| HessianFactor ()
| default constructor for I/O
| HessianFactor (Key j, const Matrix &G, const Vector &g, double f)
| Construct a unary factor.
| HessianFactor (Key j, const Vector &mu, const Matrix &Sigma)
| Construct a unary factor, given a mean and covariance matrix.
| HessianFactor (Key j1, Key j2, const Matrix &G11, const Matrix &G12, const Vector &g1, const Matrix &G22, const Vector &g2, double f)
| Construct a binary factor.
| HessianFactor (Key j1, Key j2, Key j3, const Matrix &G11, const Matrix &G12, const Matrix &G13, const Vector &g1, const Matrix &G22, const Matrix &G23, const Vector &g2, const Matrix &G33, const Vector &g3, double f)
| Construct a ternary factor.
| HessianFactor (const KeyVector &js, const std::vector< Matrix > &Gs, const std::vector< Vector > &gs, double f)
| Construct an n-way factor.
template<typename KEYS>
| HessianFactor (const KEYS &keys, const SymmetricBlockMatrix &augmentedInformation)
| Constructor with an arbitrary number of keys and with the augmented information matrix specified as a block matrix.
| HessianFactor (const JacobianFactor &cg)
| Construct from a JacobianFactor (or from a GaussianConditional since it derives from it).
| HessianFactor (const GaussianFactor &factor)
| Attempt to construct from any GaussianFactor - currently supports JacobianFactor, HessianFactor, GaussianConditional, or any derived classes.
| HessianFactor (const GaussianFactorGraph &factors, const Scatter &scatter)
| Combine a set of factors into a single dense HessianFactor.
| HessianFactor (const GaussianFactorGraph &factors)
| Combine a set of factors into a single dense HessianFactor.
| ~HessianFactor () override
| Destructor.
GaussianFactor::shared_ptr | clone () const override
| Clone this HessianFactor.
void | print (const std::string &s="", const KeyFormatter &formatter=DefaultKeyFormatter) const override
| Print the factor for debugging and testing (implementing Testable).
bool | equals (const GaussianFactor &lf, double tol=1e-9) const override
| Compare to another factor for testing (implementing Testable).
double | error (const VectorValues &c) const override
| Evaluate the factor error f(x).
DenseIndex | getDim (const_iterator variable) const override
| Return the dimension of the variable pointed to by the given key iterator todo: Remove this in favor of keeping track of dimensions with variables?
size_t | rows () const
| Return the number of columns and rows of the Hessian matrix, including the information vector.
GaussianFactor::shared_ptr | negate () const override
| Construct the corresponding anti-factor to negate information stored stored in this factor.
double | constantTerm () const
| Return the constant term \( f \) as described above.
double & | constantTerm ()
| Return the constant term \( f \) as described above.
SymmetricBlockMatrix::constBlock | linearTerm (const_iterator j) const
| Return the part of linear term \( g \) as described above corresponding to the requested variable.
SymmetricBlockMatrix::constBlock | linearTerm () const
| Return the complete linear term \( g \) as described above.
SymmetricBlockMatrix::Block | linearTerm ()
| Return the complete linear term \( g \) as described above.
const SymmetricBlockMatrix & | info () const
| Return underlying information matrix.
SymmetricBlockMatrix & | info ()
| Return non-const information matrix.
Matrix | augmentedInformation () const override
| Return the augmented information matrix represented by this GaussianFactor.
Eigen::SelfAdjointView< SymmetricBlockMatrix::constBlock, Eigen::Upper > | informationView () const
| Return self-adjoint view onto the information matrix (NOT augmented).
Matrix | information () const override
| Return the non-augmented information matrix represented by this GaussianFactor.
void | hessianDiagonalAdd (VectorValues &d) const override
| Add the current diagonal to a VectorValues instance.
void | hessianDiagonal (double *d) const override
| Raw memory access version of hessianDiagonal.
std::map< Key, Matrix > | hessianBlockDiagonal () const override
| Return the block diagonal of the Hessian for this factor.
std::pair< Matrix, Vector > | jacobian () const override
| Return (dense) matrix associated with factor.
Matrix | augmentedJacobian () const override
| Return (dense) matrix associated with factor The returned system is an augmented matrix: [A b].
void | updateHessian (const KeyVector &keys, SymmetricBlockMatrix *info) const override
| Update an information matrix by adding the information corresponding to this factor (used internally during elimination).
void | updateHessian (HessianFactor *other) const
| Update another Hessian factor.
void | multiplyHessianAdd (double alpha, const VectorValues &x, VectorValues &y) const override
| y += alpha * A'*A*x
VectorValues | gradientAtZero () const override
| eta for Hessian
void | gradientAtZero (double *d) const override
| Raw memory access version of gradientAtZero.
Vector | gradient (Key key, const VectorValues &x) const override
| Compute the gradient at a key: \( \grad f(x_i) = \sum_j G_ij*x_j - g_i \).
boost::shared_ptr< GaussianConditional > | eliminateCholesky (const Ordering &keys)
| In-place elimination that returns a conditional on (ordered) keys specified, and leaves this factor to be on the remaining keys (separator) only.
VectorValues | solve ()
| Solve the system A'*A delta = A'*b in-place, return delta as VectorValues.
double | error (const HybridValues &c) const override
| All factor types need to implement an error function.
VectorValues | hessianDiagonal () const
| Using the base method.
Public Member Functions inherited from gtsam::GaussianFactor
| GaussianFactor ()
| Default constructor creates empty factor.
template<typename CONTAINER>
| GaussianFactor (const CONTAINER &keys)
| Construct from container of keys.
virtual | ~GaussianFactor ()
| Destructor.
VectorValues | hessianDiagonal () const
| Return the diagonal of the Hessian for this factor.
Public Member Functions inherited from gtsam::Factor
virtual | ~Factor ()=default
| Default destructor.
bool | empty () const
| Whether the factor is empty (involves zero variables).
Key | front () const
| First key.
Key | back () const
| Last key.
const_iterator | find (Key key) const
| find
const KeyVector & | keys () const
| Access the factor's involved variable keys.
const_iterator | begin () const
| Iterator at beginning of involved variable keys.
const_iterator | end () const
| Iterator at end of involved variable keys.
size_t | size () const
virtual void | printKeys (const std::string &s="Factor", const KeyFormatter &formatter=DefaultKeyFormatter) const
| print only keys
bool | equals (const This &other, double tol=1e-9) const
| check equality
KeyVector & | keys ()
iterator | begin ()
| Iterator at beginning of involved variable keys.
iterator | end ()
| Iterator at end of involved variable keys.

## Public Types

typedef GaussianFactor | Base
| Typedef to base class.
typedef HessianFactor | This
| Typedef to this class.
typedef boost::shared_ptr< This > | shared_ptr
| A shared_ptr to this class.
typedef SymmetricBlockMatrix::Block | Block
| A block from the Hessian matrix.
typedef SymmetricBlockMatrix::constBlock | constBlock
| A block from the Hessian matrix (const version).
Public Types inherited from gtsam::GaussianFactor
typedef GaussianFactor | This
| This class.
typedef boost::shared_ptr< This > | shared_ptr
| shared_ptr to this class
typedef Factor | Base
| Our base class.
Public Types inherited from gtsam::Factor
typedef KeyVector::iterator | iterator
| Iterator over keys.
typedef KeyVector::const_iterator | const_iterator
| Const iterator over keys.

## Protected Attributes

SymmetricBlockMatrix | info_
| The full augmented information matrix, s.t. the quadratic error is 0.5*[x -1]'H[x -1].
Protected Attributes inherited from gtsam::Factor
KeyVector | keys_
| The keys involved in this factor.

## Friends

class | NonlinearFactorGraph
class | NonlinearClusterTree
class | boost::serialization::access
| Serialization function.

## Additional Inherited Members

Static Public Member Functions inherited from gtsam::GaussianFactor
template<typename CONTAINER>
static DenseIndex | Slot (const CONTAINER &keys, Key key)
| Factor ()
| Default constructor for I/O.
template<typename CONTAINER>
| Factor (const CONTAINER &keys)
| Construct factor from container of keys.
template<typename ITERATOR>
| Factor (ITERATOR first, ITERATOR last)
| Construct factor from iterator keys.
template<typename CONTAINER>
static Factor | FromKeys (const CONTAINER &keys)
| Construct factor from container of keys.
template<typename ITERATOR>
static Factor | FromIterators (ITERATOR first, ITERATOR last)
| Construct factor from iterator keys.

## Constructor & Destructor Documentation

## HessianFactor() [1/5]

gtsam::HessianFactor::HessianFactor | ( | Key | j,
|  | const Matrix & | G,
|  | const Vector & | g,
|  | double | f )

Construct a unary factor.

G is the quadratic term (Hessian matrix), g the linear term (a vector), and f the constant term. The quadratic error is: 0.5*(f - 2*x'*g + x'*G*x)

## HessianFactor() [2/5]

gtsam::HessianFactor::HessianFactor | ( | Key | j,
|  | const Vector & | mu,
|  | const Matrix & | Sigma )

Construct a unary factor, given a mean and covariance matrix.

error is 0.5*(x-mu)'inv(Sigma)(x-mu)

## HessianFactor() [3/5]

gtsam::HessianFactor::HessianFactor | ( | Key | j1,
|  | Key | j2,
|  | const Matrix & | G11,
|  | const Matrix & | G12,
|  | const Vector & | g1,
|  | const Matrix & | G22,
|  | const Vector & | g2,
|  | double | f )

Construct a binary factor.

Gxx are the upper-triangle blocks of the quadratic term (the Hessian matrix), gx the pieces of the linear vector term, and f the constant term. JacobianFactor error is

\[ 0.5* (Ax-b)' M (Ax-b) = 0.5*x'A'MAx - x'A'Mb + 0.5*b'Mb \]

HessianFactor error is

\[ 0.5*(x'Gx - 2x'g + f) = 0.5*x'Gx - x'*g + 0.5*f \]

So, with \( A = [A1 A2] \) and \( G=A*'M*A = [A1';A2']*M*[A1 A2] \) we have

n1*n1 G11 = A1'*M*A1
n1*n2 G12 = A1'*M*A2
n2*n2 G22 = A2'*M*A2
n1*1 g1 = A1'*M*b
n2*1 g2 = A2'*M*b
1*1 f = b'*M*b

## HessianFactor() [4/5]

gtsam::HessianFactor::HessianFactor | ( | Key | j1,
|  | Key | j2,
|  | Key | j3,
|  | const Matrix & | G11,
|  | const Matrix & | G12,
|  | const Matrix & | G13,
|  | const Vector & | g1,
|  | const Matrix & | G22,
|  | const Matrix & | G23,
|  | const Vector & | g2,
|  | const Matrix & | G33,
|  | const Vector & | g3,
|  | double | f )

Construct a ternary factor.

Gxx are the upper-triangle blocks of the quadratic term (the Hessian matrix), gx the pieces of the linear vector term, and f the constant term.

## HessianFactor() [5/5]

gtsam::HessianFactor::HessianFactor | ( | const KeyVector & | js,
|  | const std::vector< Matrix > & | Gs,
|  | const std::vector< Vector > & | gs,
|  | double | f )

Construct an n-way factor.

Gs contains the upper-triangle blocks of the quadratic term (the Hessian matrix) provided in row-order, gs the pieces of the linear vector term, and f the constant term.

## Member Function Documentation

## augmentedInformation()

Matrix gtsam::HessianFactor::augmentedInformation | ( |  | ) | const

override virtual

Return the augmented information matrix represented by this GaussianFactor.

The augmented information matrix contains the information matrix with an additional column holding the information vector, and an additional row holding the transpose of the information vector. The lower-right entry contains the constant error term (when \( \delta x = 0 \)). The augmented information matrix is described in more detail in HessianFactor, which in fact stores an augmented information matrix.

For HessianFactor, this is the same as info() except that this function returns a complete symmetric matrix whereas info() returns a matrix where only the upper triangle is valid, but should be interpreted as symmetric. This is because info() returns only a reference to the internal representation of the augmented information matrix, which stores only the upper triangle.

Implements gtsam::GaussianFactor.

## augmentedJacobian()

Matrix gtsam::HessianFactor::augmentedJacobian | ( |  | ) | const

override virtual

Return (dense) matrix associated with factor The returned system is an augmented matrix: [A b].

Parameters

  set | weight to use whitening to bake in weights

Implements gtsam::GaussianFactor.

## clone()

GaussianFactor::shared_ptr gtsam::HessianFactor::clone | ( |  | ) | const

inline override virtual

Clone this HessianFactor.

Implements gtsam::GaussianFactor.

## constantTerm() [1/2]

double & gtsam::HessianFactor::constantTerm | ( |  | ) |

inline

Return the constant term \( f \) as described above.

Returns
  The constant term \( f \)

## constantTerm() [2/2]

double gtsam::HessianFactor::constantTerm | ( |  | ) | const

inline

Return the constant term \( f \) as described above.

Returns
  The constant term \( f \)

## eliminateCholesky()

boost::shared_ptr< GaussianConditional > gtsam::HessianFactor::eliminateCholesky | ( | const Ordering & | keys | ) |

In-place elimination that returns a conditional on (ordered) keys specified, and leaves this factor to be on the remaining keys (separator) only.

Does dense partial Cholesky.

## equals()

bool gtsam::HessianFactor::equals | ( | const GaussianFactor & | lf,
|  | double | tol = 1e-9 ) const

override virtual

Compare to another factor for testing (implementing Testable).

Implements gtsam::GaussianFactor.

## error() [1/2]

double GaussianFactor::error | ( | const HybridValues & | c | ) | const

override virtual

All factor types need to implement an error function.

In factor graphs, this is the negative log-likelihood.

Reimplemented from gtsam::GaussianFactor.

## error() [2/2]

double gtsam::HessianFactor::error | ( | const VectorValues & | c | ) | const

override virtual

Evaluate the factor error f(x).

returns 0.5*[x -1]'H[x -1] (also see constructor documentation)

Reimplemented from gtsam::GaussianFactor.

## getDim()

DenseIndex gtsam::HessianFactor::getDim | ( | const_iterator | variable | ) | const

inline override virtual

Return the dimension of the variable pointed to by the given key iterator todo: Remove this in favor of keeping track of dimensions with variables?

Parameters

  variable | An iterator pointing to the slot in this factor. You can use, for example, begin() + 2 to get the 3rd variable in this factor.

Implements gtsam::GaussianFactor.

## gradient()

Vector gtsam::HessianFactor::gradient | ( | Key | key,
|  | const VectorValues & | x ) const

override virtual

Compute the gradient at a key: \( \grad f(x_i) = \sum_j G_ij*x_j - g_i \).

Implements gtsam::GaussianFactor.

## gradientAtZero() [1/2]

VectorValues gtsam::HessianFactor::gradientAtZero | ( |  | ) | const

override virtual

eta for Hessian

Implements gtsam::GaussianFactor.

## gradientAtZero() [2/2]

void gtsam::HessianFactor::gradientAtZero | ( | double * | d | ) | const

override virtual

Raw memory access version of gradientAtZero.

Implements gtsam::GaussianFactor.

Reimplemented in gtsam::RegularHessianFactor< D >.

## hessianBlockDiagonal()

map< Key, Matrix > gtsam::HessianFactor::hessianBlockDiagonal | ( |  | ) | const

override virtual

Return the block diagonal of the Hessian for this factor.

Implements gtsam::GaussianFactor.

## hessianDiagonal()

void gtsam::HessianFactor::hessianDiagonal | ( | double * | d | ) | const

override virtual

Raw memory access version of hessianDiagonal.

Implements gtsam::GaussianFactor.

Reimplemented in gtsam::RegularHessianFactor< D >.

## hessianDiagonalAdd()

void gtsam::HessianFactor::hessianDiagonalAdd | ( | VectorValues & | d | ) | const

override virtual

Add the current diagonal to a VectorValues instance.

Implements gtsam::GaussianFactor.

## info()

SymmetricBlockMatrix & gtsam::HessianFactor::info | ( |  | ) |

inline

Return non-const information matrix.

TODO(gareth): Review the sanity of having non-const access to this.

## information()

Matrix gtsam::HessianFactor::information | ( |  | ) | const

override virtual

Return the non-augmented information matrix represented by this GaussianFactor.

Implements gtsam::GaussianFactor.

## jacobian()

std::pair< Matrix, Vector > gtsam::HessianFactor::jacobian | ( |  | ) | const

override virtual

Return (dense) matrix associated with factor.

Implements gtsam::GaussianFactor.

## linearTerm() [1/3]

SymmetricBlockMatrix::Block gtsam::HessianFactor::linearTerm | ( |  | ) |

inline

Return the complete linear term \( g \) as described above.

Returns
  The linear term \( g \)

## linearTerm() [2/3]

SymmetricBlockMatrix::constBlock gtsam::HessianFactor::linearTerm | ( |  | ) | const

inline

Return the complete linear term \( g \) as described above.

Returns
  The linear term \( g \)

## linearTerm() [3/3]

SymmetricBlockMatrix::constBlock gtsam::HessianFactor::linearTerm | ( | const_iterator | j | ) | const

inline

Return the part of linear term \( g \) as described above corresponding to the requested variable.

Parameters

  j | Which block row to get, as an iterator pointing to the slot in this factor. You can use, for example, begin() + 2 to get the 3rd variable in this factor.

Returns
  The linear term \( g \)

## multiplyHessianAdd()

void gtsam::HessianFactor::multiplyHessianAdd | ( | double | alpha,
|  | const VectorValues & | x,
|  | VectorValues & | y ) const

override virtual

y += alpha * A'*A*x

Implements gtsam::GaussianFactor.

Reimplemented in gtsam::RegularHessianFactor< D >.

## negate()

GaussianFactor::shared_ptr gtsam::HessianFactor::negate | ( |  | ) | const

override virtual

Construct the corresponding anti-factor to negate information stored stored in this factor.

Returns
  a HessianFactor with negated Hessian matrices

Implements gtsam::GaussianFactor.

## print()

void gtsam::HessianFactor::print | ( | const std::string & | s = "",
|  | const KeyFormatter & | formatter = DefaultKeyFormatter ) const

override virtual

Print the factor for debugging and testing (implementing Testable).

Implements gtsam::GaussianFactor.

## updateHessian() [1/2]

void gtsam::HessianFactor::updateHessian | ( | const KeyVector & | keys,
|  | SymmetricBlockMatrix * | info ) const

override virtual

Update an information matrix by adding the information corresponding to this factor (used internally during elimination).

Parameters

  keys | THe ordered vector of keys for the information matrix to be updated
  info | The information matrix to be updated

Implements gtsam::GaussianFactor.

## updateHessian() [2/2]

void gtsam::HessianFactor::updateHessian | ( | HessianFactor * | other | ) | const

inline

Update another Hessian factor.

Parameters

  other | the HessianFactor to be updated

The documentation for this class was generated from the following files:

- /build/gtsam-RkN8wG/gtsam-4.2.2+dfsg/gtsam/linear/HessianFactor.h
- /build/gtsam-RkN8wG/gtsam-4.2.2+dfsg/gtsam/linear/HessianFactor-inl.h
- /build/gtsam-RkN8wG/gtsam-4.2.2+dfsg/gtsam/linear/HessianFactor.cpp