gtsam 4.2.0
gtsam
Loading...
Searching...
No Matches
gtsam::DecisionTreeFactor Class Reference

Detailed Description

A discrete probabilistic factor.

+ Inheritance diagram for gtsam::DecisionTreeFactor:

Standard Interface

double evaluate (const DiscreteValues &values) const
 Calculate probability for given values x, is just look up in AlgebraicDecisionTree.
 
double operator() (const DiscreteValues &values) const override
 Evaluate probability density, sugar.
 
double error (const DiscreteValues &values) const
 Calculate error for DiscreteValues x, is -log(probability).
 
DecisionTreeFactor operator* (const DecisionTreeFactor &f) const override
 multiply two factors
 
size_t cardinality (Key j) const
 
DecisionTreeFactor operator/ (const DecisionTreeFactor &f) const
 divide by factor f (safely)
 
DecisionTreeFactor toDecisionTreeFactor () const override
 Convert into a decisiontree.
 
shared_ptr sum (size_t nrFrontals) const
 Create new factor by summing all values with the same separator values.
 
shared_ptr sum (const Ordering &keys) const
 Create new factor by summing all values with the same separator values.
 
shared_ptr max (size_t nrFrontals) const
 Create new factor by maximizing over all values with the same separator.
 
shared_ptr max (const Ordering &keys) const
 Create new factor by maximizing over all values with the same separator.
 
static double safe_div (const double &a, const double &b)
 

Public Member Functions

Standard Constructors
 DecisionTreeFactor ()
 Default constructor for I/O.
 
 DecisionTreeFactor (const DiscreteKeys &keys, const ADT &potentials)
 Constructor from DiscreteKeys and AlgebraicDecisionTree.
 
 DecisionTreeFactor (const DiscreteKeys &keys, const std::vector< double > &table)
 Constructor from doubles.
 
 DecisionTreeFactor (const DiscreteKeys &keys, const std::string &table)
 Constructor from string.
 
template<class SOURCE >
 DecisionTreeFactor (const DiscreteKey &key, SOURCE table)
 Single-key specialization.
 
 DecisionTreeFactor (const DiscreteKey &key, const std::vector< double > &row)
 Single-key specialization, with vector of doubles.
 
 DecisionTreeFactor (const DiscreteConditional &c)
 Construct from a DiscreteConditional type.
 
Testable
bool equals (const DiscreteFactor &other, double tol=1e-9) const override
 equality
 
void print (const std::string &s="DecisionTreeFactor:\n", const KeyFormatter &formatter=DefaultKeyFormatter) const override
 print
 
Advanced Interface
DecisionTreeFactor apply (const DecisionTreeFactor &f, ADT::Binary op) const
 Apply binary operator (*this) "op" f.
 
shared_ptr combine (size_t nrFrontals, ADT::Binary op) const
 Combine frontal variables using binary operator "op".
 
shared_ptr combine (const Ordering &keys, ADT::Binary op) const
 Combine frontal variables in an Ordering using binary operator "op".
 
std::vector< std::pair< DiscreteValues, double > > enumerate () const
 Enumerate all values into a map from values to double.
 
DiscreteKeys discreteKeys () const
 Return all the discrete keys associated with this factor.
 
DecisionTreeFactor prune (size_t maxNrAssignments) const
 Prune the decision tree of discrete variables.
 
Wrapper support
void dot (std::ostream &os, const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
 output to graphviz format, stream version
 
void dot (const std::string &name, const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
 output to graphviz format, open a file
 
std::string dot (const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
 output to graphviz format string
 
std::string markdown (const KeyFormatter &keyFormatter=DefaultKeyFormatter, const Names &names={}) const override
 Render as markdown table.
 
std::string html (const KeyFormatter &keyFormatter=DefaultKeyFormatter, const Names &names={}) const override
 Render as html table.
 
HybridValues methods.
double error (const HybridValues &values) const override
 Calculate error for HybridValues x, is -log(probability) Simply dispatches to DiscreteValues version.
 
- Public Member Functions inherited from gtsam::DiscreteFactor
 DiscreteFactor ()
 Default constructor creates empty factor.
 
template<typename CONTAINER >
 DiscreteFactor (const CONTAINER &keys)
 Construct from container of keys.
 
virtual ~DiscreteFactor ()
 Virtual destructor.
 
void print (const std::string &s="DiscreteFactor\n", const KeyFormatter &formatter=DefaultKeyFormatter) const override
 print
 
double error (const DiscreteValues &values) const
 Error is just -log(value)
 
double error (const HybridValues &c) const override
 All factor types need to implement an error function.
 
- 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 KeyVectorkeys () 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
 
KeyVectorkeys ()
 
iterator begin ()
 Iterator at beginning of involved variable keys.
 
iterator end ()
 Iterator at end of involved variable keys.
 
- Public Member Functions inherited from gtsam::AlgebraicDecisionTree< Key >
 AlgebraicDecisionTree (double leaf=1.0)
 
 AlgebraicDecisionTree (const Base &add)
 
 AlgebraicDecisionTree (const Key &label, double y1, double y2)
 Create a new leaf function splitting on a variable.
 
 AlgebraicDecisionTree (const typename Base::LabelC &labelC, double y1, double y2)
 Create a new leaf function splitting on a variable.
 
 AlgebraicDecisionTree (const std::vector< typename Base::LabelC > &labelCs, const std::vector< double > &ys)
 Create from keys and vector table.
 
 AlgebraicDecisionTree (const std::vector< typename Base::LabelC > &labelCs, const std::string &table)
 Create from keys and string table.
 
 AlgebraicDecisionTree (Iterator begin, Iterator end, const Key &label)
 Create a new function splitting on a variable.
 
 AlgebraicDecisionTree (const AlgebraicDecisionTree< M > &other, const std::map< M, Key > &map)
 Convert labels from type M to type L.
 
AlgebraicDecisionTree operator+ (const AlgebraicDecisionTree &g) const
 sum
 
AlgebraicDecisionTree operator* (const AlgebraicDecisionTree &g) const
 product
 
AlgebraicDecisionTree operator/ (const AlgebraicDecisionTree &g) const
 division
 
AlgebraicDecisionTree sum (const Key &label, size_t cardinality) const
 sum out variable
 
AlgebraicDecisionTree sum (const typename Base::LabelC &labelC) const
 sum out variable
 
void print (const std::string &s="", const typename Base::LabelFormatter &labelFormatter=&DefaultFormatter) const
 print method customized to value type double.
 
bool equals (const AlgebraicDecisionTree &other, double tol=1e-9) const
 Equality method customized to value type double.
 
- Public Member Functions inherited from gtsam::DecisionTree< L, Y >
 DecisionTree ()
 Default constructor (for serialization)
 
 DecisionTree (const Y &y)
 Create a constant.
 
 DecisionTree (const L &label, const Y &y1, const Y &y2)
 Create tree with 2 assignments y1, y2, splitting on variable label
 
 DecisionTree (const LabelC &label, const Y &y1, const Y &y2)
 Allow Label+Cardinality for convenience.
 
 DecisionTree (const std::vector< LabelC > &labelCs, const std::vector< Y > &ys)
 Create from keys and a corresponding vector of values.
 
 DecisionTree (const std::vector< LabelC > &labelCs, const std::string &table)
 Create from keys and string table.
 
template<typename Iterator >
 DecisionTree (Iterator begin, Iterator end, const L &label)
 Create DecisionTree from others.
 
 DecisionTree (const L &label, const DecisionTree &f0, const DecisionTree &f1)
 Create DecisionTree from two others.
 
template<typename X , typename Func >
 DecisionTree (const DecisionTree< L, X > &other, Func Y_of_X)
 Convert from a different value type.
 
template<typename M , typename X , typename Func >
 DecisionTree (const DecisionTree< M, X > &other, const std::map< M, L > &map, Func Y_of_X)
 Convert from a different value type X to value type Y, also transate labels via map from type M to L.
 
void print (const std::string &s, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter) const
 GTSAM-style print.
 
bool equals (const DecisionTree &other, const CompareFunc &compare=&DefaultCompare) const
 
virtual ~DecisionTree ()=default
 Make virtual.
 
bool empty () const
 Check if tree is empty.
 
bool operator== (const DecisionTree &q) const
 equality
 
const Y & operator() (const Assignment< L > &x) const
 evaluate
 
template<typename Func >
void visit (Func f) const
 Visit all leaves in depth-first fashion.
 
template<typename Func >
void visitLeaf (Func f) const
 Visit all leaves in depth-first fashion.
 
template<typename Func >
void visitWith (Func f) const
 Visit all leaves in depth-first fashion.
 
size_t nrLeaves () const
 Return the number of leaves in the tree.
 
template<typename Func , typename X >
fold (Func f, X x0) const
 Fold a binary function over the tree, returning accumulator.
 
std::set< L > labels () const
 Retrieve all unique labels as a set.
 
DecisionTree apply (const Unary &op) const
 apply Unary operation "op" to f
 
DecisionTree apply (const UnaryAssignment &op) const
 Apply Unary operation "op" to f while also providing the corresponding assignment.
 
DecisionTree apply (const DecisionTree &g, const Binary &op) const
 apply binary operation "op" to f and g
 
DecisionTree choose (const L &label, size_t index) const
 create a new function where value(label)==index It's like "restrict" in Darwiche09book pg329, 330?
 
DecisionTree combine (const L &label, size_t cardinality, const Binary &op) const
 combine subtrees on key with binary operation "op"
 
DecisionTree combine (const LabelC &labelC, const Binary &op) const
 combine with LabelC for convenience
 
void dot (std::ostream &os, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
 output to graphviz format, stream version
 
void dot (const std::string &name, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
 output to graphviz format, open a file
 
std::string dot (const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
 output to graphviz format string
 
 DecisionTree (const NodePtr &root)
 
template<typename Iterator >
NodePtr compose (Iterator begin, Iterator end, const L &label) const
 

Public Types

typedef DecisionTreeFactor This
 
typedef DiscreteFactor Base
 Typedef to base class.
 
typedef boost::shared_ptr< DecisionTreeFactorshared_ptr
 
typedef AlgebraicDecisionTree< KeyADT
 
- Public Types inherited from gtsam::DiscreteFactor
typedef DiscreteFactor This
 This class.
 
typedef boost::shared_ptr< DiscreteFactorshared_ptr
 shared_ptr to this class
 
typedef Factor Base
 Our base class.
 
using Values = DiscreteValues
 backwards compatibility
 
using Names = DiscreteValues::Names
 Translation table from values to strings.
 
- Public Types inherited from gtsam::Factor
typedef KeyVector::iterator iterator
 Iterator over keys.
 
typedef KeyVector::const_iterator const_iterator
 Const iterator over keys.
 
- Public Types inherited from gtsam::AlgebraicDecisionTree< Key >
using Base = DecisionTree< Key, double >
 
- Public Types inherited from gtsam::DecisionTree< L, Y >
using LabelFormatter = std::function< std::string(L)>
 
using ValueFormatter = std::function< std::string(Y)>
 
using CompareFunc = std::function< bool(const Y &, const Y &)>
 
using Unary = std::function< Y(const Y &)>
 Handy typedefs for unary and binary function types.
 
using UnaryAssignment = std::function< Y(const Assignment< L > &, const Y &)>
 
using Binary = std::function< Y(const Y &, const Y &)>
 
using LabelC = std::pair< L, size_t >
 A label annotated with cardinality.
 
using NodePtr = typename Node::Ptr
 ---------------------— Node base class ------------------------—
 

Protected Attributes

std::map< Key, size_t > cardinalities_
 
- Protected Attributes inherited from gtsam::Factor
KeyVector keys_
 The keys involved in this factor.
 

Friends

class boost::serialization::access
 Serialization function.
 

Additional Inherited Members

- Public Attributes inherited from gtsam::DecisionTree< L, Y >
NodePtr root_
 A DecisionTree just contains the root. TODO(dellaert): make protected.
 
- Protected Member Functions inherited from gtsam::Factor
 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.
 
- Protected Member Functions inherited from gtsam::DecisionTree< L, Y >
template<typename It , typename ValueIt >
NodePtr create (It begin, It end, ValueIt beginY, ValueIt endY) const
 Internal recursive function to create from keys, cardinalities, and Y values.
 
template<typename M , typename X >
NodePtr convertFrom (const typename DecisionTree< M, X >::NodePtr &f, std::function< L(const M &)> L_of_M, std::function< Y(const X &)> Y_of_X) const
 Convert from a DecisionTree<M, X> to DecisionTree<L, Y>.
 
- Static Protected Member Functions inherited from gtsam::Factor
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.
 
- Static Protected Member Functions inherited from gtsam::DecisionTree< L, Y >
static bool DefaultCompare (const Y &a, const Y &b)
 Default method for comparison of two objects of type Y.
 

Member Function Documentation

◆ apply()

DecisionTreeFactor gtsam::DecisionTreeFactor::apply ( const DecisionTreeFactor f,
ADT::Binary  op 
) const

Apply binary operator (*this) "op" f.

Parameters
fthe second argument for op
opa binary operator that operates on AlgebraicDecisionTree

◆ combine() [1/2]

DecisionTreeFactor::shared_ptr gtsam::DecisionTreeFactor::combine ( const Ordering keys,
ADT::Binary  op 
) const

Combine frontal variables in an Ordering using binary operator "op".

Parameters
nrFrontalsnr. of frontal to combine variables in this factor
opa binary operator that operates on AlgebraicDecisionTree
Returns
shared pointer to newly created DecisionTreeFactor

◆ combine() [2/2]

DecisionTreeFactor::shared_ptr gtsam::DecisionTreeFactor::combine ( size_t  nrFrontals,
ADT::Binary  op 
) const

Combine frontal variables using binary operator "op".

Parameters
nrFrontalsnr. of frontal to combine variables in this factor
opa binary operator that operates on AlgebraicDecisionTree
Returns
shared pointer to newly created DecisionTreeFactor

◆ equals()

bool gtsam::DecisionTreeFactor::equals ( const DiscreteFactor other,
double  tol = 1e-9 
) const
overridevirtual

equality

Implements gtsam::DiscreteFactor.

Reimplemented in gtsam::DiscreteConditional.

◆ error()

double gtsam::DecisionTreeFactor::error ( const HybridValues values) const
overridevirtual

Calculate error for HybridValues x, is -log(probability) Simply dispatches to DiscreteValues version.

Reimplemented from gtsam::Factor.

Reimplemented in gtsam::DiscreteConditional.

◆ html()

string gtsam::DecisionTreeFactor::html ( const KeyFormatter keyFormatter = DefaultKeyFormatter,
const Names names = {} 
) const
overridevirtual

Render as html table.

Parameters
keyFormatterGTSAM-style Key formatter.
namesoptional, category names corresponding to choices.
Returns
std::string a html string.

Implements gtsam::DiscreteFactor.

Reimplemented in gtsam::DiscreteConditional.

◆ markdown()

string gtsam::DecisionTreeFactor::markdown ( const KeyFormatter keyFormatter = DefaultKeyFormatter,
const Names names = {} 
) const
overridevirtual

Render as markdown table.

Parameters
keyFormatterGTSAM-style Key formatter.
namesoptional, category names corresponding to choices.
Returns
std::string a markdown string.

Implements gtsam::DiscreteFactor.

Reimplemented in gtsam::DiscreteConditional.

◆ operator()()

double gtsam::DecisionTreeFactor::operator() ( const DiscreteValues values) const
inlineoverridevirtual

Evaluate probability density, sugar.

Implements gtsam::DiscreteFactor.

◆ operator*()

DecisionTreeFactor gtsam::DecisionTreeFactor::operator* ( const DecisionTreeFactor f) const
inlineoverridevirtual

multiply two factors

Implements gtsam::DiscreteFactor.

◆ print()

void gtsam::DecisionTreeFactor::print ( const std::string &  s = "DecisionTreeFactor:\n",
const KeyFormatter formatter = DefaultKeyFormatter 
) const
overridevirtual

◆ prune()

DecisionTreeFactor gtsam::DecisionTreeFactor::prune ( size_t  maxNrAssignments) const

Prune the decision tree of discrete variables.

Pruning will set the leaves to be "pruned" to 0 indicating a 0 probability. An assignment is pruned if it is not in the top maxNrAssignments values.

A violation can occur if there are more duplicate values than maxNrAssignments. A violation here is the need to un-prune the decision tree (e.g. all assignment values are 1.0). We could have another case where some subset of duplicates exist (e.g. for a tree with 8 assignments we have 1, 1, 1, 1, 0.8, 0.7, 0.6, 0.5), but this is not a violation since the for maxNrAssignments=5 the top values are (1, 0.8).

Parameters
maxNrAssignmentsThe maximum number of assignments to keep.
Returns
DecisionTreeFactor

◆ toDecisionTreeFactor()

DecisionTreeFactor gtsam::DecisionTreeFactor::toDecisionTreeFactor ( ) const
inlineoverridevirtual

Convert into a decisiontree.

Implements gtsam::DiscreteFactor.


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