DecisionTreeFactor.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
 * See LICENSE for the license information
 
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <gtsam/discrete/AlgebraicDecisionTree.h>
#include <gtsam/discrete/DiscreteFactor.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/discrete/Ring.h>
#include <gtsam/inference/Ordering.h>
 
#include <algorithm>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace gtsam {
 
  class DiscreteConditional;
  class HybridValues;
 
  class GTSAM_EXPORT DecisionTreeFactor : public DiscreteFactor,
                                          public AlgebraicDecisionTree<Key> {
   public:
    // typedefs needed to play nice with gtsam
    typedef DecisionTreeFactor This;
    typedef DiscreteFactor Base;  
    typedef std::shared_ptr<DecisionTreeFactor> shared_ptr;
    typedef AlgebraicDecisionTree<Key> ADT;
 
    // Needed since we have definitions in both DiscreteFactor and DecisionTree
    using Base::Binary;
    using Base::Unary;
    using Base::UnaryAssignment;
 
 
    DecisionTreeFactor();
 
    DecisionTreeFactor(const DiscreteKeys& keys, const ADT& potentials);
 
    DecisionTreeFactor(const DiscreteKeys& keys,
                       const std::vector<double>& table);
 
    DecisionTreeFactor(const DiscreteKeys& keys, const std::string& table);
 
    template <class SOURCE>
    DecisionTreeFactor(const DiscreteKey& key, SOURCE table)
        : DecisionTreeFactor(DiscreteKeys{key}, table) {}
 
    DecisionTreeFactor(const DiscreteKey& key, const std::vector<double>& row)
        : DecisionTreeFactor(DiscreteKeys{key}, row) {}
 
    explicit DecisionTreeFactor(const DiscreteConditional& c);
 
 
    bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
 
    // print
    void print(
        const std::string& s = "DecisionTreeFactor:\n",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
 
    virtual double evaluate(const Assignment<Key>& values) const override {
      return ADT::operator()(values);
    }
 
    using DiscreteFactor::operator();
 
    double error(const DiscreteValues& values) const override;
 
    virtual DiscreteFactor::shared_ptr multiply(
        const DiscreteFactor::shared_ptr& f) const override;
 
    DiscreteFactor::shared_ptr operator*(double s) const override {
      return std::make_shared<DecisionTreeFactor>(
          apply([s](const double& a) { return Ring::mul(a, s); }));
    }
 
    DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override {
      return apply(f, Ring::mul);
    }
 
    static double safe_div(const double& a, const double& b);
 
    DecisionTreeFactor operator/(const DecisionTreeFactor& f) const {
      return apply(f, safe_div);
    }
 
    DiscreteFactor::shared_ptr operator/(
        const DiscreteFactor::shared_ptr& f) const override;
 
    DecisionTreeFactor toDecisionTreeFactor() const override { return *this; }
 
    DiscreteFactor::shared_ptr sum(size_t nrFrontals) const override {
      return combine(nrFrontals, Ring::add);
    }
 
    DiscreteFactor::shared_ptr sum(const Ordering& keys) const override {
      return combine(keys, Ring::add);
    }
 
    double max() const override { return ADT::max(); };
 
    DiscreteFactor::shared_ptr max(size_t nrFrontals) const override {
      return combine(nrFrontals, Ring::max);
    }
 
    DiscreteFactor::shared_ptr max(const Ordering& keys) const override {
      return combine(keys, Ring::max);
    }
 
    DiscreteFactor::shared_ptr restrict(
        const DiscreteValues& assignment) const override;
        
 
    DecisionTreeFactor apply(Unary op) const;
 
    DecisionTreeFactor apply(UnaryAssignment op) const;
 
    DecisionTreeFactor apply(const DecisionTreeFactor& f, Binary op) const;
 
    shared_ptr combine(size_t nrFrontals, Binary op) const;
 
    shared_ptr combine(const Ordering& keys, Binary op) const;
 
    std::vector<std::pair<DiscreteValues, double>> enumerate() const;
 
    std::vector<double> probabilities() const;
 
    double computeThreshold(const size_t N) const;
 
    DecisionTreeFactor prune(size_t maxNrAssignments) const;
 
    uint64_t nrValues() const override { return nrLeaves(); }
 
 
    void dot(std::ostream& os,
            const KeyFormatter& keyFormatter = DefaultKeyFormatter,
            bool showZero = true) const;
 
    void dot(const std::string& name,
            const KeyFormatter& keyFormatter = DefaultKeyFormatter,
            bool showZero = true) const;
 
    std::string dot(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                    bool showZero = true) const;
 
    std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                        const Names& names = {}) const override;
 
    std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                    const Names& names = {}) const override;
 
 
  double error(const HybridValues& values) const override;
 
 
   private:
#if GTSAM_ENABLE_BOOST_SERIALIZATION
 
    friend class boost::serialization::access;
    template <class ARCHIVE>
    void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
      ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
      ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(ADT);
    }
#endif
  };
 
// traits
template <>
struct traits<DecisionTreeFactor> : public Testable<DecisionTreeFactor> {};
}  // namespace gtsam