gtsam 4.2.0
gtsam
DecisionTreeFactor.h
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2
3 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4 * Atlanta, Georgia 30332-0415
5 * All Rights Reserved
6 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7
8 * See LICENSE for the license information
9
10 * -------------------------------------------------------------------------- */
11
19#pragma once
20
25
26#include <algorithm>
27#include <boost/shared_ptr.hpp>
28#include <map>
29#include <stdexcept>
30#include <string>
31#include <utility>
32#include <vector>
33
34namespace gtsam {
35
36 class DiscreteConditional;
37 class HybridValues;
38
44 class GTSAM_EXPORT DecisionTreeFactor : public DiscreteFactor,
45 public AlgebraicDecisionTree<Key> {
46 public:
47 // typedefs needed to play nice with gtsam
50 typedef boost::shared_ptr<DecisionTreeFactor> shared_ptr;
52
53 protected:
54 std::map<Key, size_t> cardinalities_;
55
56 public:
59
62
64 DecisionTreeFactor(const DiscreteKeys& keys, const ADT& potentials);
65
68 const std::vector<double>& table);
69
71 DecisionTreeFactor(const DiscreteKeys& keys, const std::string& table);
72
74 template <class SOURCE>
75 DecisionTreeFactor(const DiscreteKey& key, SOURCE table)
76 : DecisionTreeFactor(DiscreteKeys{key}, table) {}
77
79 DecisionTreeFactor(const DiscreteKey& key, const std::vector<double>& row)
81
83 explicit DecisionTreeFactor(const DiscreteConditional& c);
84
88
90 bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
91
92 // print
93 void print(
94 const std::string& s = "DecisionTreeFactor:\n",
95 const KeyFormatter& formatter = DefaultKeyFormatter) const override;
96
100
103 double evaluate(const DiscreteValues& values) const {
104 return ADT::operator()(values);
105 }
106
108 double operator()(const DiscreteValues& values) const override {
109 return ADT::operator()(values);
110 }
111
113 double error(const DiscreteValues& values) const;
114
117 return apply(f, ADT::Ring::mul);
118 }
119
120 static double safe_div(const double& a, const double& b);
121
122 size_t cardinality(Key j) const { return cardinalities_.at(j); }
123
126 return apply(f, safe_div);
127 }
128
130 DecisionTreeFactor toDecisionTreeFactor() const override { return *this; }
131
133 shared_ptr sum(size_t nrFrontals) const {
134 return combine(nrFrontals, ADT::Ring::add);
135 }
136
138 shared_ptr sum(const Ordering& keys) const {
139 return combine(keys, ADT::Ring::add);
140 }
141
143 shared_ptr max(size_t nrFrontals) const {
144 return combine(nrFrontals, ADT::Ring::max);
145 }
146
148 shared_ptr max(const Ordering& keys) const {
149 return combine(keys, ADT::Ring::max);
150 }
151
155
161 DecisionTreeFactor apply(const DecisionTreeFactor& f, ADT::Binary op) const;
162
169 shared_ptr combine(size_t nrFrontals, ADT::Binary op) const;
170
177 shared_ptr combine(const Ordering& keys, ADT::Binary op) const;
178
180 std::vector<std::pair<DiscreteValues, double>> enumerate() const;
181
183 DiscreteKeys discreteKeys() const;
184
203 DecisionTreeFactor prune(size_t maxNrAssignments) const;
204
208
210 void dot(std::ostream& os,
211 const KeyFormatter& keyFormatter = DefaultKeyFormatter,
212 bool showZero = true) const;
213
215 void dot(const std::string& name,
216 const KeyFormatter& keyFormatter = DefaultKeyFormatter,
217 bool showZero = true) const;
218
220 std::string dot(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
221 bool showZero = true) const;
222
230 std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
231 const Names& names = {}) const override;
232
240 std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
241 const Names& names = {}) const override;
242
246
251 double error(const HybridValues& values) const override;
252
254
255 private:
257 friend class boost::serialization::access;
258 template <class ARCHIVE>
259 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
260 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
261 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(ADT);
262 ar& BOOST_SERIALIZATION_NVP(cardinalities_);
263 }
264 };
265
266// traits
267template <>
268struct traits<DecisionTreeFactor> : public Testable<DecisionTreeFactor> {};
269
270} // namespace gtsam
specialized key for discrete variables
Algebraic Decision Trees.
Variable ordering for the elimination algorithm.
std::pair< Key, size_t > DiscreteKey
Key type for discrete variables.
Definition: DiscreteKey.h:36
Global functions in a separate testing namespace.
Definition: chartTesting.h:28
string html(const DiscreteValues &values, const KeyFormatter &keyFormatter, const DiscreteValues::Names &names)
Free version of html.
Definition: DiscreteValues.cpp:134
const MATRIX::ConstRowXpr row(const MATRIX &A, size_t j)
Extracts a row view from a matrix that avoids a copy.
Definition: Matrix.h:222
string markdown(const DiscreteValues &values, const KeyFormatter &keyFormatter, const DiscreteValues::Names &names)
Free version of markdown.
Definition: DiscreteValues.cpp:129
std::string serialize(const T &input)
serializes to a string
Definition: serialization.h:113
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition: Matrix.cpp:156
DecisionTree< L, Y > apply(const DecisionTree< L, Y > &f, const typename DecisionTree< L, Y >::Unary &op)
free versions of apply
Definition: DecisionTree.h:392
double dot(const V1 &a, const V2 &b)
Dot product.
Definition: Vector.h:195
std::uint64_t Key
Integer nonlinear key type.
Definition: types.h:100
std::function< std::string(Key)> KeyFormatter
Typedef for a function to format a key, i.e. to convert it to a string.
Definition: Key.h:35
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition: concepts.h:30
Template to create a binary predicate.
Definition: Testable.h:111
A helper that implements the traits interface for GTSAM types.
Definition: Testable.h:151
Algebraic Decision Trees fix the range to double Just has some nice constructors and some syntactic s...
Definition: AlgebraicDecisionTree.h:38
A discrete probabilistic factor.
Definition: DecisionTreeFactor.h:45
shared_ptr sum(const Ordering &keys) const
Create new factor by summing all values with the same separator values.
Definition: DecisionTreeFactor.h:138
double operator()(const DiscreteValues &values) const override
Evaluate probability density, sugar.
Definition: DecisionTreeFactor.h:108
DecisionTreeFactor operator*(const DecisionTreeFactor &f) const override
multiply two factors
Definition: DecisionTreeFactor.h:116
shared_ptr max(size_t nrFrontals) const
Create new factor by maximizing over all values with the same separator.
Definition: DecisionTreeFactor.h:143
shared_ptr max(const Ordering &keys) const
Create new factor by maximizing over all values with the same separator.
Definition: DecisionTreeFactor.h:148
double evaluate(const DiscreteValues &values) const
Calculate probability for given values x, is just look up in AlgebraicDecisionTree.
Definition: DecisionTreeFactor.h:103
DiscreteFactor Base
Typedef to base class.
Definition: DecisionTreeFactor.h:49
shared_ptr sum(size_t nrFrontals) const
Create new factor by summing all values with the same separator values.
Definition: DecisionTreeFactor.h:133
DecisionTreeFactor(const DiscreteKey &key, SOURCE table)
Single-key specialization.
Definition: DecisionTreeFactor.h:75
DecisionTreeFactor toDecisionTreeFactor() const override
Convert into a decisiontree.
Definition: DecisionTreeFactor.h:130
DecisionTreeFactor operator/(const DecisionTreeFactor &f) const
divide by factor f (safely)
Definition: DecisionTreeFactor.h:125
DecisionTreeFactor(const DiscreteKey &key, const std::vector< double > &row)
Single-key specialization, with vector of doubles.
Definition: DecisionTreeFactor.h:79
Discrete Conditional Density Derives from DecisionTreeFactor.
Definition: DiscreteConditional.h:40
Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor.
Definition: DiscreteFactor.h:38
DiscreteKeys is a set of keys that can be assembled using the & operator.
Definition: DiscreteKey.h:39
A map from keys to values.
Definition: DiscreteValues.h:34
Definition: Ordering.h:34
the error.