12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial DiscreteTableConditional

release/4.3a0
Varun Agrawal 2024-12-30 14:38:54 -05:00
parent 34fba6823a
commit de652eafc2
2 changed files with 405 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
gtsam/discrete/DiscreteTableConditional.cpp Normal file
View File

@ -0,0 +1,181 @@
/* ----------------------------------------------------------------------------
* 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
* -------------------------------------------------------------------------- */
/**
* @file DiscreteTableConditional.cpp
* @date Dec 22, 2024
* @author Varun Agrawal
*/
#include <gtsam/base/Testable.h>
#include <gtsam/base/debug.h>
#include <gtsam/discrete/DiscreteTableConditional.h>
#include <gtsam/discrete/Ring.h>
#include <gtsam/discrete/Signature.h>
#include <gtsam/hybrid/HybridValues.h>
#include <algorithm>
#include <cassert>
#include <random>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using std::pair;
using std::stringstream;
using std::vector;
namespace gtsam {
/* ************************************************************************** */
DiscreteTableConditional::DiscreteTableConditional(const size_t nrFrontals,
const TableFactor& f)
: BaseConditional(nrFrontals, DecisionTreeFactor(f.discreteKeys(), ADT())),
sparse_table_((f / (*f.sum(nrFrontals))).sparseTable()) {
// sparse_table_ = sparse_table_.prune();
}
/* ************************************************************************** */
DiscreteTableConditional::DiscreteTableConditional(
size_t nrFrontals, const DiscreteKeys& keys,
const Eigen::SparseVector<double>& potentials)
: BaseConditional(nrFrontals, keys, DecisionTreeFactor(keys, ADT())),
sparse_table_(potentials) {}
/* ************************************************************************** */
DiscreteTableConditional::DiscreteTableConditional(const TableFactor& joint,
const TableFactor& marginal)
: BaseConditional(joint.size() - marginal.size(),
joint.discreteKeys() & marginal.discreteKeys(), ADT()),
sparse_table_((joint / marginal).sparseTable()) {}
/* ************************************************************************** */
DiscreteTableConditional::DiscreteTableConditional(const TableFactor& joint,
const TableFactor& marginal,
const Ordering& orderedKeys)
: DiscreteTableConditional(joint, marginal) {
keys_.clear();
keys_.insert(keys_.end(), orderedKeys.begin(), orderedKeys.end());
}
/* ************************************************************************** */
DiscreteTableConditional::DiscreteTableConditional(const Signature& signature)
: BaseConditional(1, DecisionTreeFactor()),
sparse_table_(TableFactor(signature.discreteKeys(), signature.cpt())
.sparseTable()) {}
/* ************************************************************************** */
DiscreteTableConditional DiscreteTableConditional::operator*(
const DiscreteTableConditional& other) const {
// Take union of frontal keys
std::set<Key> newFrontals;
for (auto&& key : this->frontals()) newFrontals.insert(key);
for (auto&& key : other.frontals()) newFrontals.insert(key);
// Check if frontals overlapped
if (nrFrontals() + other.nrFrontals() > newFrontals.size())
throw std::invalid_argument(
"DiscreteTableConditional::operator* called with overlapping frontal "
"keys.");
// Now, add cardinalities.
DiscreteKeys discreteKeys;
for (auto&& key : frontals())
discreteKeys.emplace_back(key, cardinality(key));
for (auto&& key : other.frontals())
discreteKeys.emplace_back(key, other.cardinality(key));
// Sort
std::sort(discreteKeys.begin(), discreteKeys.end());
// Add parents to set, to make them unique
std::set<DiscreteKey> parents;
for (auto&& key : this->parents())
if (!newFrontals.count(key)) parents.emplace(key, cardinality(key));
for (auto&& key : other.parents())
if (!newFrontals.count(key)) parents.emplace(key, other.cardinality(key));
// Finally, add parents to keys, in order
for (auto&& dk : parents) discreteKeys.push_back(dk);
TableFactor a(this->discreteKeys(), this->sparse_table_),
b(other.discreteKeys(), other.sparse_table_);
TableFactor product = a * other;
return DiscreteTableConditional(newFrontals.size(), product);
}
/* ************************************************************************** */
void DiscreteTableConditional::print(const string& s,
const KeyFormatter& formatter) const {
cout << s << " P( ";
for (const_iterator it = beginFrontals(); it != endFrontals(); ++it) {
cout << formatter(*it) << " ";
}
if (nrParents()) {
cout << "| ";
for (const_iterator it = beginParents(); it != endParents(); ++it) {
cout << formatter(*it) << " ";
}
}
cout << "):\n";
// BaseFactor::print("", formatter);
cout << endl;
}
/* ************************************************************************** */
bool DiscreteTableConditional::equals(const DiscreteFactor& other,
double tol) const {
if (!dynamic_cast<const DiscreteConditional*>(&other)) {
return false;
} else {
const DiscreteConditional& f(
static_cast<const DiscreteConditional&>(other));
return DiscreteConditional::equals(f, tol);
}
}
/* ************************************************************************** */
TableFactor::shared_ptr DiscreteTableConditional::likelihood(
const DiscreteValues& frontalValues) const {
throw std::runtime_error("Likelihood not implemented");
}
/* ****************************************************************************/
TableFactor::shared_ptr DiscreteTableConditional::likelihood(
size_t frontal) const {
throw std::runtime_error("Likelihood not implemented");
}
/* ************************************************************************** */
size_t DiscreteTableConditional::argmax(
const DiscreteValues& parentsValues) const {
// Initialize
size_t maxValue = 0;
double maxP = 0;
DiscreteValues values = parentsValues;
assert(nrFrontals() == 1);
Key j = firstFrontalKey();
for (size_t value = 0; value < cardinality(j); value++) {
values[j] = value;
double pValueS = (*this)(values);
// Update MPE solution if better
if (pValueS > maxP) {
maxP = pValueS;
maxValue = value;
}
}
return maxValue;
}
} // namespace gtsam

224
gtsam/discrete/DiscreteTableConditional.h Normal file
View File

@ -0,0 +1,224 @@
/* ----------------------------------------------------------------------------
* 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
* -------------------------------------------------------------------------- */
/**
* @file DiscreteTableConditional.h
* @date Dec 22, 2024
* @author Varun Agrawal
*/
#pragma once
#include <gtsam/discrete/DiscreteConditional.h>
#include <gtsam/discrete/Signature.h>
#include <gtsam/discrete/TableFactor.h>
#include <gtsam/inference/Conditional-inst.h>
#include <memory>
#include <string>
#include <vector>
namespace gtsam {
/**
* Discrete Conditional Density which uses a SparseTable as the internal
* representation, similar to the TableFactor.
*
* @ingroup discrete
*/
class GTSAM_EXPORT DiscreteTableConditional : public DiscreteConditional {
Eigen::SparseVector<double> sparse_table_;
public:
// typedefs needed to play nice with gtsam
typedef DiscreteTableConditional This; ///< Typedef to this class
typedef std::shared_ptr<This> shared_ptr; ///< shared_ptr to this class
typedef DiscreteConditional
BaseConditional; ///< Typedef to our conditional base class
using Values = DiscreteValues; ///< backwards compatibility
/// @name Standard Constructors
/// @{
/// Default constructor needed for serialization.
DiscreteTableConditional() {}
/// Construct from factor, taking the first `nFrontals` keys as frontals.
DiscreteTableConditional(size_t nFrontals, const TableFactor& f);
/**
* Construct from DiscreteKeys and SparseVector, taking the first
* `nFrontals` keys as frontals, in the order given.
*/
DiscreteTableConditional(size_t nFrontals, const DiscreteKeys& keys,
const Eigen::SparseVector<double>& potentials);
/** Construct from signature */
explicit DiscreteTableConditional(const Signature& signature);
/**
* Construct from key, parents, and a Signature::Table specifying the
* conditional probability table (CPT) in 00 01 10 11 order. For
* three-valued, it would be 00 01 02 10 11 12 20 21 22, etc....
*
* Example: DiscreteTableConditional P(D, {B,E}, table);
*/
DiscreteTableConditional(const DiscreteKey& key, const DiscreteKeys& parents,
const Signature::Table& table)
: DiscreteTableConditional(Signature(key, parents, table)) {}
/**
* Construct from key, parents, and a vector<double> specifying the
* conditional probability table (CPT) in 00 01 10 11 order. For
* three-valued, it would be 00 01 02 10 11 12 20 21 22, etc....
*
* Example: DiscreteTableConditional P(D, {B,E}, table);
*/
DiscreteTableConditional(const DiscreteKey& key, const DiscreteKeys& parents,
const std::vector<double>& table)
: DiscreteTableConditional(
1, TableFactor(DiscreteKeys{key} & parents, table)) {}
/**
* Construct from key, parents, and a string specifying the conditional
* probability table (CPT) in 00 01 10 11 order. For three-valued, it would
* be 00 01 02 10 11 12 20 21 22, etc....
*
* The string is parsed into a Signature::Table.
*
* Example: DiscreteTableConditional P(D, {B,E}, "9/1 2/8 3/7 1/9");
*/
DiscreteTableConditional(const DiscreteKey& key, const DiscreteKeys& parents,
const std::string& spec)
: DiscreteTableConditional(Signature(key, parents, spec)) {}
/// No-parent specialization; can also use DiscreteDistribution.
DiscreteTableConditional(const DiscreteKey& key, const std::string& spec)
: DiscreteTableConditional(Signature(key, {}, spec)) {}
/**
* @brief construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y)
* Assumes but *does not check* that f(Y)=sum_X f(X,Y).
*/
DiscreteTableConditional(const TableFactor& joint,
const TableFactor& marginal);
/**
* @brief construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y)
* Assumes but *does not check* that f(Y)=sum_X f(X,Y).
* Makes sure the keys are ordered as given. Does not check orderedKeys.
*/
DiscreteTableConditional(const TableFactor& joint,
const TableFactor& marginal,
const Ordering& orderedKeys);
/**
* @brief Combine two conditionals, yielding a new conditional with the union
* of the frontal keys, ordered by gtsam::Key.
*
* The two conditionals must make a valid Bayes net fragment, i.e.,
* the frontal variables cannot overlap, and must be acyclic:
* Example of correct use:
* P(A,B) = P(A|B) * P(B)
* P(A,B|C) = P(A|B) * P(B|C)
* P(A,B,C) = P(A,B|C) * P(C)
* Example of incorrect use:
* P(A|B) * P(A|C) = ?
* P(A|B) * P(B|A) = ?
* We check for overlapping frontals, but do *not* check for cyclic.
*/
DiscreteTableConditional operator*(
const DiscreteTableConditional& other) const;
/// @}
/// @name Testable
/// @{
/// GTSAM-style print
void print(
const std::string& s = "Discrete Conditional: ",
const KeyFormatter& formatter = DefaultKeyFormatter) const override;
/// GTSAM-style equals
bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
/// @}
/// @name Standard Interface
/// @{
/// Log-probability is just -error(x).
double logProbability(const DiscreteValues& x) const { return -error(x); }
/// print index signature only
void printSignature(
const std::string& s = "Discrete Conditional: ",
const KeyFormatter& formatter = DefaultKeyFormatter) const {
static_cast<const BaseConditional*>(this)->print(s, formatter);
}
/** Convert to a likelihood factor by providing value before bar. */
TableFactor::shared_ptr likelihood(const DiscreteValues& frontalValues) const;
/** Single variable version of likelihood. */
TableFactor::shared_ptr likelihood(size_t frontal) const;
/**
* @brief Return assignment for single frontal variable that maximizes value.
* @param parentsValues Known assignments for the parents.
* @return maximizing assignment for the frontal variable.
*/
size_t argmax(const DiscreteValues& parentsValues = DiscreteValues()) const;
/// @}
/// @name Advanced Interface
/// @{
/// Return all assignments for frontal variables.
std::vector<DiscreteValues> frontalAssignments() const;
/// Return all assignments for frontal *and* parent variables.
std::vector<DiscreteValues> allAssignments() const;
/// @}
/// @name HybridValues methods.
/// @{
using BaseConditional::operator(); ///< HybridValues version
/**
* Calculate log-probability log(evaluate(x)) for HybridValues `x`.
* This is actually just -error(x).
*/
double logProbability(const HybridValues& x) const override {
return -error(x);
}
/// @}
private:
#if GTSAM_ENABLE_BOOST_SERIALIZATION
/** Serialization function */
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int /*version*/) {
ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseConditional);
}
#endif
};
// DiscreteTableConditional
// traits
template <>
struct traits<DiscreteTableConditional>
: public Testable<DiscreteTableConditional> {};
} // namespace gtsam