gum::credal::CredalNet< GUM_SCALAR > Class Template Reference

Class template representing a Credal Network. More...

#include <agrum/CN/credalNet.h>

Collaboration diagram for gum::credal::CredalNet< GUM_SCALAR >:

Public Member Functions
void	saveBNsMinMax (const std::string &min_path, const std::string &max_path) const
	If this CredalNet was built over a perturbed BayesNet, one can save the intervals as two BayesNet. More...
std::string	toString () const
void	computeBinaryCPTMinMax ()
	Used with binary networks to speed-up L2U inference. More...
Constructors / Destructors
	CredalNet ()
	Constructor used to create a CredalNet step by step, i.e. More...
	CredalNet (const std::string &src_min_num, const std::string &src_max_den="")
	Constructor for interval defined credal network which takes 2 BayesNet file path. More...
	CredalNet (const BayesNet< GUM_SCALAR > &src_min_num, const BayesNet< GUM_SCALAR > &src_max_den=BayesNet< GUM_SCALAR >())
	Constructor for interval defined credal network which takes 2 BayesNet. More...
	~CredalNet ()
	Destructor. More...
Credal network creation
NodeId	addVariable (const std::string &name, const Size &card)
	Adds a discrete node into the network. More...
void	addArc (const NodeId &tail, const NodeId &head)
	Adds an arc between two nodes. More...
void	setCPTs (const NodeId &id, const std::vector< std::vector< std::vector< GUM_SCALAR > > > &cpt)
	Set the vertices of the credal sets ( all of the conditionals ) of a given node More...
void	setCPT (const NodeId &id, Size &entry, const std::vector< std::vector< GUM_SCALAR > > &cpt)
	Set the vertices of one credal set of a given node ( any instantiation index ) More...
void	setCPT (const NodeId &id, Instantiation ins, const std::vector< std::vector< GUM_SCALAR > > &cpt)
	Set the vertices of one credal set of a given node ( any instantiation ) More...
void	fillConstraints (const NodeId &id, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of the credal sets of a given node (all instantiations ) More...
void	fillConstraint (const NodeId &id, const Idx &entry, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of a credal set of a given node ( from an instantiation index ) More...
void	fillConstraint (const NodeId &id, Instantiation ins, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of a credal sets of a given node ( from an instantiation ) More...
Instantiation	instantiation (const NodeId &id)
	Get an Instantiation from a node id, usefull to fill the constraints of the network More...
Size	domainSize (const NodeId &id)
	Get the cardinality of a node More...
Public manipulation methods
void	bnToCredal (const GUM_SCALAR beta, const bool oneNet, const bool keepZeroes=false)
	Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set. More...
void	intervalToCredalWithFiles ()
void	intervalToCredal ()
	Computes the vertices of each credal set according to their interval definition (uses lrs). More...
void	lagrangeNormalization ()
	Normalize counts of a BayesNet storing counts of each events such that no probability is 0. More...
void	idmLearning (const Idx s=0, const bool keepZeroes=false)
	Learns parameters from a BayesNet storing counts of events. More...
void	approximatedBinarization ()
	Approximate binarization. More...
Getters and setters
const BayesNet< GUM_SCALAR > &	src_bn () const
const BayesNet< GUM_SCALAR > &	current_bn () const
const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > &	credalNet_currentCpt () const
const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > &	credalNet_srcCpt () const
NodeType	currentNodeType (const NodeId &id) const
NodeType	nodeType (const NodeId &id) const
const GUM_SCALAR &	epsilonMin () const
const GUM_SCALAR &	epsilonMax () const
const GUM_SCALAR &	epsilonMean () const
const bool	isSeparatelySpecified () const
const bool	hasComputedBinaryCPTMinMax () const
const std::vector< std::vector< GUM_SCALAR > > &	get_binaryCPT_min () const
	Used with binary networks to speed-up L2U inference. More...
const std::vector< std::vector< GUM_SCALAR > > &	get_binaryCPT_max () const
	Used with binary networks to speed-up L2U inference. More...

Public Types
enum	NodeType : char { NodeType::Precise, NodeType::Credal, NodeType::Vacuous, NodeType::Indic }
	NodeType to speed-up computations in some algorithms. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::credal::CredalNet< GUM_SCALAR >

Class template representing a Credal Network.

Template Parameters

GUM_SCALAR

A floating type ( float, GUM_SCALAR, long GUM_SCALAR ... ).

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 88 of file credalNet.h.

Member Enumeration Documentation

NodeType

template<typename GUM_SCALAR >

enum gum::credal::CredalNet::NodeType : char

strong

NodeType to speed-up computations in some algorithms.

Enumerator
Precise
Credal
Vacuous
Indic

Definition at line 91 of file credalNet.h.

                          : char
      {
        Precise,
        Credal,
        Vacuous,
        Indic
      };

Constructor & Destructor Documentation

CredalNet() [1/3]

template<typename GUM_SCALAR >

gum::credal::CredalNet< GUM_SCALAR >::CredalNet

(

)

Constructor used to create a CredalNet step by step, i.e.

node by node, arc by arc, manually filling potentials.

Definition at line 31 of file credalNet_tpl.h.

                                       {
      _initParams_();

      _src_bn_     = BayesNet< GUM_SCALAR >();
      _src_bn_min_ = BayesNet< GUM_SCALAR >();
      _src_bn_max_ = BayesNet< GUM_SCALAR >();

      GUM_CONSTRUCTOR(CredalNet);
    }

CredalNet() [2/3]

template<typename GUM_SCALAR >

gum::credal::CredalNet< GUM_SCALAR >::CredalNet	(	const std::string &	src_min_num,
		const std::string &	src_max_den = ""
	)

Constructor for interval defined credal network which takes 2 BayesNet file path.

One can also provide a single BayesNet in order to perturb it's probability distributions into credal sets according to another BayesNet containing the number of cases, for each node, of each parent instantiation met during learning, i.e. \( p(X = 0 \mid pa(X) = j) = N_{pa(X) = j} \).

Parameters

src_min_num	The path to a BayesNet which contains lower probabilities.
src_max_den	The ( optional ) path to a BayesNet which contains upper probabilities.

Definition at line 390 of file credalNet_tpl.h.

                                                                     {
      _initParams_();
      _initCNNets_(src_min_num, src_max_den);

      GUM_CONSTRUCTOR(CredalNet);
    }

CredalNet() [3/3]

template<typename GUM_SCALAR >

gum::credal::CredalNet< GUM_SCALAR >::CredalNet	(	const BayesNet< GUM_SCALAR > &	src_min_num,
		const BayesNet< GUM_SCALAR > &	src_max_den = BayesNet< GUM_SCALAR >()
	)

Constructor for interval defined credal network which takes 2 BayesNet.

One can also provide a single BayesNet in order to perturb it's probability distributions into credal sets according to another BayesNet containing the number of cases, for each node, of each parent instantiation met during learning, i.e. \( p(X = 0 \mid pa(X) = j) = N_{pa(X) = j} \).

Parameters

src_min_num	The BayesNet which contains lower probabilities.
src_max_den	The ( optional ) BayesNet which contains upper probabilities.

Definition at line 399 of file credalNet_tpl.h.

                                                                                  {
      _initParams_();
      _initCNNets_(src_min_num, src_max_den);

      GUM_CONSTRUCTOR(CredalNet);
    }

~CredalNet()

template<typename GUM_SCALAR >

gum::credal::CredalNet< GUM_SCALAR >::~CredalNet

(

)

Destructor.

Definition at line 408 of file credalNet_tpl.h.

                                        {
      if (_current_bn_ != nullptr) delete _current_bn_;

      if (_credalNet_current_cpt_ != nullptr) delete _credalNet_current_cpt_;

      if (_current_nodeType_ != nullptr) delete _current_nodeType_;

      GUM_DESTRUCTOR(CredalNet);
    }

Member Function Documentation

_bnCopy_()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_bnCopy_ ( BayesNet< GUM_SCALAR > &  bn_dest )

private

Deprecated:

Warning

May be useless since the BayesNet copy constructor seems to now work well (parent order is preserved).

Copy the up-to-date BayesNet associated with this CredalNet. Since all we care about is the DAG, only arcs are copied. Because the order with which arcs are created is important, the function iterates over the CPTs variables to be sure parent order stays the same from a net to it's copy.

Parameters

bn_dest

The reference to the new copy

Definition at line 1446 of file credalNet_tpl.h.

                                                                       {
      const BayesNet< GUM_SCALAR >* _current_bn_;

      if (this->_current_bn_ == nullptr)
        _current_bn_ = &this->_src_bn_;
      else
        _current_bn_ = this->_current_bn_;

      for (auto node: _current_bn_->nodes())
        dest.add(_current_bn_->variable(node));

      dest.beginTopologyTransformation();

      for (auto node: _current_bn_->nodes()) {
        for (auto parent_idIt: _current_bn_->cpt(node).variablesSequence()) {
          if (_current_bn_->nodeId(*parent_idIt) != node)
            dest.addArc(_current_bn_->nodeId(*parent_idIt), node);
        }   // end of : for each parent in order of appearence
      }     // end of : for each variable

      dest.endTopologyTransformation();
    }

_find_dNode_card_()

template<typename GUM_SCALAR >

int gum::credal::CredalNet< GUM_SCALAR >::_find_dNode_card_ ( const std::vector< std::vector< std::vector< GUM_SCALAR > > > &  var_cpt ) const

private

Deprecated:

Parameters

var_cpt

The reference to a node CPT which may need a Decision Node.

Returns

Returns the cardinality of the Decision Node.

Definition at line 1434 of file credalNet_tpl.h.

                                                                               {
      Size vertices_size = 0;

      for (auto entry = var_cpt.cbegin(), theEnd = var_cpt.cend(); entry != theEnd; ++entry) {
        if (entry->size() > vertices_size) vertices_size = Size(entry->size());
      }

      return int(vertices_size);
    }

_H2Vlrs_()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_H2Vlrs_ ( const std::vector< std::vector< GUM_SCALAR > > &  h_rep, std::vector< std::vector< GUM_SCALAR > > &  v_rep  ) const

private

Deprecated:

one should use the LrsWrapper class Computes the V-representation of a credal set, i.e.

it's vertices, from it's H-representation, i.e. the hyper-plan inequalities. Uses lrs.

Parameters

h_rep	A constant reference to the H-representation of a credal set.
v_rep	A reference to the V-representation of the same credal set.

Definition at line 1522 of file credalNet_tpl.h.

                                                                                              {
      // write H rep file
      int64_t num, den;

      std::string sinefile = getUniqueFileName();   // generate unique file name, we
      // need to add .ine or .ext for lrs
      // to know which input it is (Hrep
      // to Vrep or Vrep to Hrep)
      sinefile += ".ine";

      std::ofstream h_file(sinefile.c_str(), std::ios::out | std::ios::trunc);

      if (!h_file.good())
        GUM_ERROR(IOError, " __H2Vlrs : could not open lrs input file : " << sinefile)

      h_file << "H - representation\n";
      h_file << "begin\n";
      h_file << h_rep.size() << ' ' << h_rep[0].size() << " rational\n";

      for (auto it = h_rep.cbegin(), theEnd = h_rep.cend(); it != theEnd; ++it) {
        for (auto it2 = it->cbegin(), theEnd2 = it->cend(); it2 != theEnd2; ++it2) {
          // get integer fraction from decimal value
          // smallest numerator & denominator is farley, also
          // best precision
          Rational< GUM_SCALAR >::farey(num,
                                        den,
                                        ((*it2 > 0) ? *it2 : -*it2),
                                        int64_t(_denMax_),
                                        _epsF_);

          h_file << ((*it2 > 0) ? num : -num) << '/' << den << ' ';
        }

        h_file << '\n';
      }

      h_file << "end\n";
      h_file.close();

      // call lrs
      // lrs arguments
      char* args[3];

      std::string soft_name = "lrs";
      std::string extfile(sinefile);
      extfile += ".ext";

      args[0] = new char[soft_name.size()];
      args[1] = new char[sinefile.size()];
      args[2] = new char[extfile.size()];

      strcpy(args[0], soft_name.c_str());
      strcpy(args[1], sinefile.c_str());
      strcpy(args[2], extfile.c_str());

      // standard cout to null (avoid lrs flooding)
      int old_cout, new_cout;
      fflush(stdout);
      old_cout = dup(1);

      new_cout = open("/dev/null", O_WRONLY);
      dup2(new_cout, 1);
      close(new_cout);

      lrs_main(3, args);

      // restore standard cout
      fflush(stdout);
      dup2(old_cout, 1);
      close(old_cout);

      delete[] args[2];
      delete[] args[1];
      delete[] args[0];

      // read V rep file
      std::ifstream v_file(extfile.c_str() /*extfilename.c_str()*/, std::ios::in);

      if (!v_file.good()) GUM_ERROR(IOError, " __H2Vlrs : could not open lrs ouput file : ")

      std::string line, tmp;
      char *      cstr, *p;
      GUM_SCALAR  probability;

      std::string::size_type pos;
      bool                   keep_going = true;
      // int vertices;

      std::vector< GUM_SCALAR > vertex;

      v_file.ignore(256, 'l');

      while (v_file.good() && keep_going) {
        getline(v_file, line);

        if (line.size() == 0)
          continue;
        else if (line.compare("end") == 0) {
          keep_going = false;
          // this is to get vertices number :
          /*getline ( v_file, line );
          std::string::size_type pos, end_pos;
          pos = line.find ( "vertices = " );
          end_pos = line.find ( "rays", pos + 9 );
          vertices = atoi ( line.substr ( pos + 9, end_pos - pos - 9 ).c_str()
          );*/
          break;
        } else if (line[1] != '1') {
          GUM_ERROR(IOError,
                    " __H2Vlrs : reading something other than a vertex from "
                    "lrs output file : ");
        }

        line = line.substr(2);
        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());

        p = strtok(cstr, " ");

        while (p != nullptr) {
          tmp = p;

          if (tmp.compare("1") == 0 || tmp.compare("0") == 0)
            probability = GUM_SCALAR(atof(tmp.c_str()));
          else {
            pos         = tmp.find("/");
            probability = GUM_SCALAR(atof(tmp.substr(0, pos).c_str())
                                     / atof(tmp.substr(pos + 1, tmp.size()).c_str()));
          }

          vertex.push_back(probability);
          p = strtok(nullptr, " ");
        }   // end of : for all tokens

        delete[] p;
        delete[] cstr;

        bool is_redund = false;

#pragma omp parallel
        {
          int this_thread = getThreadNumber();
          int num_threads = getNumberOfRunningThreads();

          auto begin_pos = (this_thread + 0) * v_rep.size() / num_threads;
          auto end_pos   = (this_thread + 1) * v_rep.size() / num_threads;

          for (auto p = begin_pos; p < end_pos; p++) {
#pragma omp flush(is_redund)

            if (is_redund) break;

            bool thread_redund = true;

            auto vsize = vertex.size();

            for (Size modality = 0; modality < vsize; modality++) {
              if (std::fabs(vertex[modality] - v_rep[p][modality]) > _epsRedund_) {
                thread_redund = false;
                break;
              }
            }

            if (thread_redund) {
              is_redund = true;
#pragma omp flush(is_redund)
            }
          }   // end of : each thread for
        }     // end of : parallel

        if (!is_redund) v_rep.push_back(vertex);

        vertex.clear();

      }   // end of : file

      v_file.close();

      if (std::remove(sinefile.c_str()) != 0) GUM_ERROR(IOError, "error removing : " + sinefile)

      if (std::remove(extfile.c_str()) != 0) GUM_ERROR(IOError, "error removing : " + extfile)
    }

_initCNNets_() [1/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_initCNNets_ ( const std::string &  src_min_num, const std::string &  src_max_den  )

private

Initialize private BayesNet variables after the Constructor has been called.

Definition at line 1403 of file credalNet_tpl.h.

                                                                             {
      BIFReader< GUM_SCALAR > reader(&_src_bn_, src_min_num);
      std::string             other;

      if (src_max_den.compare("") != 0)
        other = src_max_den;
      else
        other = src_min_num;

      BIFReader< GUM_SCALAR > reader_min(&_src_bn_min_, src_min_num);
      BIFReader< GUM_SCALAR > reader_max(&_src_bn_max_, other);

      reader.proceed();
      reader_min.proceed();
      reader_max.proceed();
    }

_initCNNets_() [2/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_initCNNets_ ( const BayesNet< GUM_SCALAR > &  src_min_num, const BayesNet< GUM_SCALAR > &  src_max_den  )

private

Initialize private BayesNet variables after the Constructor has been called.

Definition at line 1422 of file credalNet_tpl.h.

                                                                                          {
      _src_bn_     = src_min_num;
      _src_bn_min_ = src_min_num;

      if (src_max_den.size() > 0)
        _src_bn_max_ = src_max_den;
      else
        _src_bn_max_ = src_min_num;
    }

_initParams_()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_initParams_ ( )

private

Initialize private constant variables after the Constructor has been called.

Definition at line 1376 of file credalNet_tpl.h.

                                               {
      _epsilonMin_ = 0;
      _epsilonMax_ = 0;
      _epsilonMoy_ = 0;

      _epsRedund_ = GUM_SCALAR(1e-6);

      // farey algorithm
      _epsF_   = GUM_SCALAR(1e-6);
      _denMax_ = GUM_SCALAR(1e6);   // beware LRSWrapper

      // continued fractions, beware LRSWrapper
      // decimal paces ( _epsC_ *  _precisionC_ == 1)
      _precisionC_ = GUM_SCALAR(1e6);
      _deltaC_     = 5;

      // old custom algorithm
      _precision_ = GUM_SCALAR(1e6);   // beware LRSWrapper

      _current_bn_            = nullptr;
      _credalNet_current_cpt_ = nullptr;
      _current_nodeType_      = nullptr;

      _hasComputedBinaryCPTMinMax_ = false;
    }

_intervalToCredal_()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_intervalToCredal_ ( )

private

Computes the vertices of each credal set according to their interval definition (does not use lrs).

Only works with credal sets defined such that when one modality reach it's upper probability, all others are at their lowest.

Called by bnToCredal and idmLearning.

Definition at line 674 of file credalNet_tpl.h.

                                                     {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();

      _credalNet_src_cpt_.resize(_src_bn_.size());

      for (auto node: _src_bn_.nodes()) {
        const Potential< GUM_SCALAR >* const potential_min(&_src_bn_min_.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(&_src_bn_max_.cpt(node));

        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_max);

        ins_min.setFirst();
        ins_max.setFirst();

        std::vector< GUM_SCALAR > lower(var_dSize);
        std::vector< GUM_SCALAR > upper(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          for (Size modality = 0; modality < var_dSize; modality++, ++ins_min, ++ins_max) {
            lower[modality] = potential_min->get(ins_min);
            upper[modality] = potential_max->get(ins_max);
          }

          bool                                     all_equals = true;
          std::vector< std::vector< GUM_SCALAR > > vertices;

          for (Size modality = 0; modality < var_dSize; modality++) {
            if (std::fabs(upper[modality] - lower[modality]) < 1e-6) continue;

            all_equals = false;
            std::vector< GUM_SCALAR > vertex(var_dSize);
            vertex[modality] = upper[modality];

            for (Size mod = 0; mod < var_dSize; mod++) {
              if (modality != mod) vertex[mod] = lower[mod];
            }

            GUM_SCALAR total = 0;

            auto vsize = vertex.size();

            for (Size i = 0; i < vsize; i++)
              total += vertex[i];

            if (std::fabs(total - 1.) > 1e-6)
              GUM_ERROR(CPTNoSumTo1,
                        _src_bn_.variable(node).name() << " " << entry << std::endl
                                                       << vertex << std::endl);

            vertices.push_back(vertex);
          }

          if (all_equals) {
            std::vector< GUM_SCALAR > vertex(var_dSize);

            for (Size modality = 0; modality < var_dSize; modality++)
              vertex[modality] = lower[modality];

            GUM_SCALAR total = 0.;

            auto vsize = vertex.size();

            for (Size i = 0; i < vsize; i++)
              total += vertex[i];

            if (std::fabs(total - 1.) > 1e-6)
              GUM_ERROR(CPTNoSumTo1,
                        _src_bn_.variable(node).name() << " " << entry << std::endl
                                                       << vertex << std::endl);

            vertices.push_back(vertex);
          }

          var_cpt[entry] = vertices;
        }

        _credalNet_src_cpt_.insert(node, var_cpt);

      }   // end of : for each variable (node)

      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

_sort_varType_()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::_sort_varType_ ( )

private

Set the NodeType of each node

Definition at line 1707 of file credalNet_tpl.h.

                                                 {
      NodeProperty< NodeType >* _current_nodeType_;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
         _credalNet_current_cpt_;

      const BayesNet< GUM_SCALAR >* _current_bn_;

      if (this->_current_bn_ == nullptr)
        _current_bn_ = &_src_bn_;
      else
        _current_bn_ = this->_current_bn_;

      if (this->_credalNet_current_cpt_ == nullptr)
        _credalNet_current_cpt_ = &_credalNet_src_cpt_;
      else
        _credalNet_current_cpt_ = this->_credalNet_current_cpt_;

      if (this->_current_nodeType_ == nullptr)
        _current_nodeType_ = &_original_nodeType_;
      else
        _current_nodeType_ = this->_current_nodeType_;

      /*if ( !  _current_nodeType_->empty() )
         _current_nodeType_->clear();*/

      for (auto node: _current_bn_->nodes()) {
        // indicatrices are already present
        if (_current_nodeType_->exists(node)) continue;

        bool precise = true, vacuous = true;

        for (auto entry   = (*_credalNet_current_cpt_)[node].cbegin(),
                  theEnd2 = (*_credalNet_current_cpt_)[node].cend();
             entry != theEnd2;
             ++entry) {
          auto vertices  = entry->size();
          auto var_dSize = (*entry)[0].size();

          if (precise && vertices > 1) precise = false;

          if (vacuous && vertices == var_dSize) {
            std::vector< bool > elem(var_dSize, false);

            for (auto vertex = entry->cbegin(), vEnd = entry->cend(); vertex != vEnd; ++vertex) {
              for (auto probability = vertex->cbegin(), pEnd = vertex->cend(); probability != pEnd;
                   ++probability) {
                if (*probability == 1) {
                  elem[probability - vertex->begin()] = true;
                  break;
                }
              }   // end of : for each modality

              break;   // not vacuous
            }          // end of : for each vertex

            for (auto /*std::vector< bool >::const_iterator*/ probability = elem.cbegin();
                 probability != elem.cend();
                 ++probability)
              if (*probability == false) vacuous = false;

          }   // end of : if vertices == dSize
          else
            vacuous = false;

          if (vacuous == false && precise == false) {
            _current_nodeType_->insert(node, NodeType::Credal);
            break;
          }

        }   // end of : for each parents entry

        if (vacuous)
          _current_nodeType_->insert(node, NodeType::Vacuous);
        else if (precise)
          _current_nodeType_->insert(node, NodeType::Precise);

      }   // end of : for each variable
    }

addArc()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::addArc	(	const NodeId &	tail,
		const NodeId &	head
	)

Adds an arc between two nodes.

Parameters

tail	The NodeId of the tail node
head	The NodeId of the head node

Definition at line 58 of file credalNet_tpl.h.

                                                                               {
      _src_bn_.addArc(tail, head);
      _src_bn_min_.addArc(tail, head);
      _src_bn_max_.addArc(tail, head);
    }

addVariable()

template<typename GUM_SCALAR >

NodeId gum::credal::CredalNet< GUM_SCALAR >::addVariable	(	const std::string &	name,
		const Size &	card
	)

Adds a discrete node into the network.

Parameters

name	The name of the discrete variable to be added
card	The cardinality of the variable

Returns

The NodeId of the variable in the network

Definition at line 42 of file credalNet_tpl.h.

                                                                                       {
      LabelizedVariable var(name, "node " + name, card);

      NodeId a = _src_bn_.add(var);
      NodeId b = _src_bn_min_.add(var);
      NodeId c = _src_bn_max_.add(var);

      if (a != b || a != c /*|| b != c*/)
        GUM_ERROR(OperationNotAllowed,
                  "addVariable : not the same id over all networks : " << a << ", " << b << ", "
                                                                       << c);

      return a;
    }

approximatedBinarization()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::approximatedBinarization

(

)

Approximate binarization.

Each bit has a lower and upper probability which is the lowest - resp. highest - over all vertices of the credal set. Enlarge the original credal sets and may induce huge imprecision.

Warning

Enlarge the original credal sets and therefore induce huge imprecision by propagation. Not recommended, use MCSampling or something else instead.

Definition at line 947 of file credalNet_tpl.h.

                                                           {
      // don't forget to delete the old one ( _current_), if necessary at the end
      auto bin_bn = new BayesNet< GUM_SCALAR >();

      // __bnCopy ( * _bin_bn_ );
      // delete old one too
      auto credalNet_bin_cpt
         = new NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >();

      // delete old one too
      auto bin_nodeType = new NodeProperty< NodeType >();

      const BayesNet< GUM_SCALAR >* current_bn;
      // const NodeProperty< nodeType > * _current_nodeType_;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
         credalNet_current_cpt;

      if (this->_current_bn_ == nullptr)
        current_bn = &this->_src_bn_;
      else
        current_bn = this->_current_bn_;

      if (this->_credalNet_current_cpt_ == nullptr)
        credalNet_current_cpt = &this->_credalNet_src_cpt_;
      else
        credalNet_current_cpt = this->_credalNet_current_cpt_;

      /*if ( this-> _current_nodeType_ == nullptr )
         _current_nodeType_ = & this-> _nodeType_;
      else
         _current_nodeType_ = this-> _current_nodeType_;*/

      if (!_var_bits_.empty()) _var_bits_.clear();

      bin_bn->beginTopologyTransformation();

      for (auto node: current_bn->nodes()) {
        auto var_dSize = current_bn->variable(node).domainSize();

        if (var_dSize != 2) {
          unsigned long b, c;
          superiorPow((unsigned long)var_dSize, b, c);
          Size nb_bits{Size(b)};

          std::string           bit_name;
          std::vector< NodeId > bits(nb_bits);

          for (Size bit = 0; bit < nb_bits; bit++) {
            bit_name = current_bn->variable(node).name() + "-b";
            std::stringstream ss;
            ss << bit;
            bit_name += ss.str();

            LabelizedVariable var_bit(bit_name, "node " + bit_name, 2);
            NodeId            iD = bin_bn->add(var_bit);

            bits[bit] = iD;
          }   // end of : for each bit

          _var_bits_.insert(node, bits);

        }   // end of : if variable is not binary
        else {
          std::string       bit_name = current_bn->variable(node).name();
          LabelizedVariable var_bit(bit_name, "node " + bit_name, 2);
          NodeId            iD = bin_bn->add(var_bit);

          _var_bits_.insert(node, std::vector< NodeId >(1, iD));
        }

      }   // end of : for each original variable

      for (auto node: current_bn->nodes()) {
        NodeSet parents = current_bn->parents(node);

        if (!parents.empty()) {
          for (auto par: current_bn->parents(node)) {
            for (Size parent_bit = 0, spbits = Size(_var_bits_[par].size()); parent_bit < spbits;
                 parent_bit++)
              for (Size var_bit = 0, mbits = Size(_var_bits_[node].size()); var_bit < mbits;
                   var_bit++)
                bin_bn->addArc(_var_bits_[par][parent_bit], _var_bits_[node][var_bit]);
          }
        }

        // arcs with one's bits
        auto bitsize = _var_bits_[node].size();

        for (Size bit_c = 1; bit_c < bitsize; bit_c++)
          for (Size bit_p = 0; bit_p < bit_c; bit_p++)
            bin_bn->addArc(_var_bits_[node][bit_p], _var_bits_[node][bit_c]);

      }   // end of : for each original variable

      bin_bn->endTopologyTransformation();

      // binarization of cpts

      auto varsize = current_bn->size();

      for (Size var = 0; var < varsize; var++) {
        auto bitsize = _var_bits_[var].size();

        for (Size i = 0; i < bitsize; i++) {
          Potential< GUM_SCALAR > const* potential(&bin_bn->cpt(_var_bits_[var][i]));
          Instantiation                  ins(potential);
          ins.setFirst();

          auto entry_size = potential->domainSize() / 2;
          std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);

          Size old_conf = 0;

          for (Size conf = 0; conf < entry_size; conf++) {
            std::vector< std::vector< GUM_SCALAR > > pvar_cpt;
            auto verticessize = (*credalNet_current_cpt)[var][old_conf].size();

            for (Size old_distri = 0; old_distri < verticessize; old_distri++) {
              const std::vector< GUM_SCALAR >& vertex
                 = (*credalNet_current_cpt)[var][old_conf][old_distri];
              auto vertexsize = vertex.size();

              std::vector< Idx > incc(vertexsize, 0);

              for (Size preced = 0; preced < i; preced++) {
                auto bit_pos = ins.pos(bin_bn->variable(_var_bits_[var][preced]));
                auto val     = ins.val(bit_pos);

                Size pas = Size(int2Pow((unsigned long)preced));
                Size elem;

                if (val == 0)
                  elem = 0;
                else
                  elem = pas;

                while (elem < vertexsize) {
                  incc[elem]++;
                  elem++;

                  if (elem % pas == 0) elem += pas;
                }
              }

              Size pas = Size(int2Pow((unsigned long)i));

              std::vector< GUM_SCALAR > distri(2, 0);
              int                       pos = 1;

              for (Size elem = 0; elem < vertexsize; elem++) {
                if (elem % pas == 0) pos = -pos;

                if (incc[elem] == i)
                  (pos < 0) ? (distri[0] += vertex[elem]) : (distri[1] += vertex[elem]);
              }

              if (i > 0) {
                GUM_SCALAR den = distri[0] + distri[1];

                if (den == 0) {
                  distri[0] = 0;
                  distri[1] = 0;
                } else {
                  distri[0] /= den;
                  distri[1] /= den;
                }
              }

              pvar_cpt.push_back(distri);

            }   // end of old distris

            // get min/max approx, 2 vertices
            std::vector< std::vector< GUM_SCALAR > > vertices(2, std::vector< GUM_SCALAR >(2, 1));
            vertices[1][1] = 0;

            auto new_verticessize = pvar_cpt.size();

            for (Size v = 0; v < new_verticessize; v++) {
              if (pvar_cpt[v][1] < vertices[0][1]) vertices[0][1] = pvar_cpt[v][1];

              if (pvar_cpt[v][1] > vertices[1][1]) vertices[1][1] = pvar_cpt[v][1];
            }

            vertices[0][0] = 1 - vertices[0][1];
            vertices[1][0] = 1 - vertices[1][1];

            pvar_cpt = vertices;

            var_cpt[conf] = pvar_cpt;

            ++ins;
            ++ins;

            old_conf++;

            if (old_conf == (*credalNet_current_cpt)[var].size()) old_conf = 0;

          }   // end of new parent conf

          credalNet_bin_cpt->insert(_var_bits_[var][i], var_cpt);

        }   // end of bit i

      }   // end of old variable

      bin_bn->beginTopologyTransformation();

      /* indicatrices variables */
      auto old_varsize = _var_bits_.size();

      for (Size i = 0; i < old_varsize; i++) {
        auto bitsize = _var_bits_[i].size();

        // binary variable
        if (bitsize == 1) continue;

        auto old_card = _src_bn_.variable(i).domainSize();

        for (Size mod = 0; mod < old_card; mod++) {
          std::stringstream ss;
          ss << _src_bn_.variable(i).name();
          ss << "-v";
          ss << mod;

          LabelizedVariable var(ss.str(), "node " + ss.str(), 2);
          const NodeId      indic = bin_bn->add(var);

          // arcs from one's bits
          for (Size bit = 0; bit < bitsize; bit++)
            bin_bn->addArc(_var_bits_[i][bit], indic);

          // cpt
          Size num = Size(int2Pow(long(bitsize)));

          std::vector< std::vector< std::vector< GUM_SCALAR > > > icpt(num);

          for (Size entry = 0; entry < num; entry++) {
            std::vector< std::vector< GUM_SCALAR > > vertices(1, std::vector< GUM_SCALAR >(2, 0));

            if (mod == entry)
              vertices[0][1] = 1;
            else
              vertices[0][0] = 1;

            icpt[entry] = vertices;
          }

          credalNet_bin_cpt->insert(indic, icpt);

          bin_nodeType->insert(indic, NodeType::Indic);
        }   // end of each modality, i.e. as many indicatrice
      }

      bin_bn->endTopologyTransformation();

      if (this->_current_bn_ != nullptr) delete this->_current_bn_;

      this->_current_bn_ = bin_bn;

      if (this->_credalNet_current_cpt_ != nullptr) delete this->_credalNet_current_cpt_;

      this->_credalNet_current_cpt_ = credalNet_bin_cpt;

      if (this->_current_nodeType_ != nullptr) delete this->_current_nodeType_;

      this->_current_nodeType_ = bin_nodeType;

      _sort_varType_();   // will fill  _bin_nodeType_ except for NodeType::Indic
                          // variables

      computeBinaryCPTMinMax();
    }

bnToCredal()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::bnToCredal	(	const GUM_SCALAR	beta,
		const bool	oneNet,
		const bool	keepZeroes = false
	)

Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.

The perturbations are done according to the number of cases met for each node and each of it's parent instantiation, i.e. \( \epsilon = *\beta^{ln(N_{pa(X) = j} + 1)} \) is the imprecision introduced which leads to \( \underline{p}(X = i \mid pa(X) = j) = (1 - \epsilon) p(X = i *\mid pa(X) = j) \) and \( \overline{p}(X = i \mid pa(X) = j) *=\underline{p}(X =i \mid pa(X) = j) + \epsilon \). Use this method when using a single BayesNet storing counts of events with oneNet set to TRUE or when using two BayesNet, one with lower probabilities and one with upper probabilities, with oneNet set to FALSE.

Parameters

beta	The beta used to perturbate the network. \( 0 \leq \beta *\leq 1 \).
oneNet	Boolean used as a flag. Set to TRUE if one BayesNet if provided with counts, to FALSE if two BayesNet are provided; one with probabilities (the lower net) and one with denominators over the first modalities (the upper net).
keepZeroes	Boolean used as a flag as whether or not - respectively TRUE or FALSE - we keep zeroes as zeroes. Default is FALSE, i.e. zeroes are not kept.

Definition at line 420 of file credalNet_tpl.h.

                                                                          {
      GUM_SCALAR epsi_min = 1.;
      GUM_SCALAR epsi_max = 0.;
      GUM_SCALAR epsi_moy = 0.;
      GUM_SCALAR epsi_den = 0.;

      for (auto node: src_bn().nodes()) {
        const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(node));

        Potential< GUM_SCALAR >* const potential_min(
           const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_min_.cpt(node)));
        Potential< GUM_SCALAR >* const potential_max(
           const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_max_.cpt(node)));

        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);
        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_max);

        ins.setFirst();
        ins_min.setFirst();
        ins_max.setFirst();

        std::vector< GUM_SCALAR > vertex(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR den;

          if (oneNet)
            den = 0;
          else
            den = potential_max->get(ins_max);

          Size nbm = 0;

          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = potential->get(ins);

            if (oneNet) {
              den += vertex[modality];

              if (vertex[modality] < 1 && vertex[modality] > 0)
                GUM_ERROR(OperationNotAllowed,
                          "bnToCredal : the BayesNet contains "
                          "probabilities and not event counts "
                          "although user precised oneNet = "
                             << oneNet);
            }

            if (vertex[modality] > 0) nbm++;

            ++ins;
          }

          if (!oneNet) {
            GUM_SCALAR sum = 0;

            for (auto modality = vertex.cbegin(), theEnd = vertex.cend(); modality != theEnd;
                 ++modality) {
              sum += *modality;
            }

            if (std::fabs(1. - sum) > _epsRedund_) {
              GUM_ERROR(CPTNoSumTo1,
                        _src_bn_.variable(node).name() << "(" << _epsRedund_ << ")"
                                                       << " " << entry << std::endl
                                                       << vertex << std::endl
                                                       << ins << std::endl);
            }
          }


          GUM_SCALAR epsilon;

          if (beta == 0)
            epsilon = 0;
          else if (den == 0 || beta == 1)
            epsilon = GUM_SCALAR(1.0);
          else
            epsilon = GUM_SCALAR(std::pow(beta, std::log1p(den)));

          epsi_moy += epsilon;
          epsi_den += 1;

          if (epsilon > epsi_max) epsi_max = epsilon;

          if (epsilon < epsi_min) epsi_min = epsilon;

          GUM_SCALAR min, max;

          for (Size modality = 0; modality < var_dSize; modality++) {
            if ((vertex[modality] > 0 && nbm > 1) || !keepZeroes) {
              min = GUM_SCALAR((1. - epsilon) * vertex[modality]);

              if (oneNet) min = GUM_SCALAR(min * 1.0 / den);

              max = GUM_SCALAR(min + epsilon);
            } else {   // if ( ( vertex[modality] == 0 && keepZeroes ) || (
              // vertex[modality] > 0 && nbm <= 1 ) || ( vertex[modality] == 0
              // && nbm <= 1 ) ) {
              min = vertex[modality];

              if (oneNet) min = GUM_SCALAR(min * 1.0 / den);

              max = min;
            }

            potential_min->set(ins_min, min);
            potential_max->set(ins_max, max);

            ++ins_min;
            ++ins_max;
          }   // end of : for each modality

        }   // end of : for each entry

      }   // end of : for each variable

      _epsilonMin_ = epsi_min;
      _epsilonMax_ = epsi_max;
      _epsilonMoy_ = (GUM_SCALAR)epsi_moy / (GUM_SCALAR)epsi_den;

      _intervalToCredal_();
    }

computeBinaryCPTMinMax()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::computeBinaryCPTMinMax

(

)

Used with binary networks to speed-up L2U inference.

Store the lower and upper probabilities of each node X over the "true" modality, i.e. respectively \( \underline{p}(X = 1 \mid pa(X) = j) \) and \( \overline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 1261 of file credalNet_tpl.h.

                                                         {
      _binCptMin_.resize(current_bn().size());
      _binCptMax_.resize(current_bn().size());

      for (auto node: current_bn().nodes()) {
        auto                      pConf = credalNet_currentCpt()[node].size();
        std::vector< GUM_SCALAR > min(pConf);
        std::vector< GUM_SCALAR > max(pConf);

        for (Size pconf = 0; pconf < pConf; pconf++) {
          GUM_SCALAR v1, v2;
          v1 = credalNet_currentCpt()[node][pconf][0][1];

          if (credalNet_currentCpt()[node][pconf].size() > 1)
            v2 = credalNet_currentCpt()[node][pconf][1][1];
          else
            v2 = v1;

          GUM_SCALAR delta = v1 - v2;
          min[pconf]       = (delta >= 0) ? v2 : v1;
          max[pconf]       = (delta >= 0) ? v1 : v2;
        }

        _binCptMin_[node] = min;
        _binCptMax_[node] = max;
      }

      _hasComputedBinaryCPTMinMax_ = true;
    }

credalNet_currentCpt()

template<typename GUM_SCALAR >

const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > & gum::credal::CredalNet< GUM_SCALAR >::credalNet_currentCpt

(

)

const

Returns

Returns a constant reference to the ( up-to-date ) CredalNet CPTs.

Definition at line 1223 of file credalNet_tpl.h.

                                                           {
      if (_credalNet_current_cpt_ != nullptr) return *_credalNet_current_cpt_;

      return _credalNet_src_cpt_;
    }

credalNet_srcCpt()

template<typename GUM_SCALAR >

const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > & gum::credal::CredalNet< GUM_SCALAR >::credalNet_srcCpt

(

)

const

Returns

Returns a constant reference to the ( up-to-date ) CredalNet CPTs.

Definition at line 1231 of file credalNet_tpl.h.

                                                       {
      return _credalNet_src_cpt_;
    }

current_bn()

template<typename GUM_SCALAR >

const BayesNet< GUM_SCALAR > & gum::credal::CredalNet< GUM_SCALAR >::current_bn

(

)

const

Returns

Returs a constant reference to the actual BayesNet (used as a DAG, it's CPTs does not matter).

Definition at line 1360 of file credalNet_tpl.h.

                                                                            {
      if (_current_bn_ != nullptr) return *_current_bn_;

      return _src_bn_;
    }

currentNodeType()

template<typename GUM_SCALAR >

CredalNet< GUM_SCALAR >::NodeType gum::credal::CredalNet< GUM_SCALAR >::currentNodeType

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the choosen NodeId

Returns

Returns the type of the choosen node in the ( up-to-date ) CredalNet current_bn if any, src_bn otherwise.

Definition at line 1237 of file credalNet_tpl.h.

                                                                      {
      if (_current_nodeType_ != nullptr) return (*(_current_nodeType_))[id];

      return _original_nodeType_[id];
    }

domainSize()

template<typename GUM_SCALAR >

INLINE Size gum::credal::CredalNet< GUM_SCALAR >::domainSize

(

const NodeId &

id

)

Get the cardinality of a node

Parameters

id	The NodeId of the node

Returns

The cardinality of the node

Definition at line 383 of file credalNet_tpl.h.

                                                                    {
      return _src_bn_.variable(id).domainSize();
    }

epsilonMax()

template<typename GUM_SCALAR >

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMax

(

)

const

Returns

Returns a constant reference to the highest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1309 of file credalNet_tpl.h.

                                                                {
      return _epsilonMax_;
    }

epsilonMean()

template<typename GUM_SCALAR >

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMean

(

)

const

Returns

Returns a constant reference to the average perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1314 of file credalNet_tpl.h.

                                                                 {
      return _epsilonMoy_;
    }

epsilonMin()

template<typename GUM_SCALAR >

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMin

(

)

const

Returns

Returns a constant reference to the lowest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1304 of file credalNet_tpl.h.

                                                                {
      return _epsilonMin_;
    }

fillConstraint() [1/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::fillConstraint	(	const NodeId &	id,
		const Idx &	entry,
		const std::vector< GUM_SCALAR > &	lower,
		const std::vector< GUM_SCALAR > &	upper
	)

Set the interval constraints of a credal set of a given node ( from an instantiation index )

Parameters

id	The NodeId of the node
entry	The index of the instantiation excluding the given node ( only the parents are used to compute the index of the credal set )
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 264 of file credalNet_tpl.h.

                                                                                       {
      Potential< GUM_SCALAR >* const potential_min(
         const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_min_.cpt(id)));
      Potential< GUM_SCALAR >* const potential_max(
         const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_max_.cpt(id)));

      auto var_dSize = _src_bn_.variable(id).domainSize();

      if (lower.size() != var_dSize || upper.size() != var_dSize)
        GUM_ERROR(SizeError,
                  "setCPT : variable modalities in cpts does not match for node id : "
                     << id << " with sizes of constraints : ( " << lower.size() << " || "
                     << upper.size() << " ) != " << var_dSize);

      auto entry_size = potential_min->domainSize() / var_dSize;

      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                     << entry << " >= " << entry_size);

      Instantiation min(potential_min);
      Instantiation max(potential_max);
      min.setFirst();
      max.setFirst();

      Idx pos = 0;

      while (pos != entry) {
        ++min;
        ++max;
        ++pos;
      }

      for (Size i = 0; i < var_dSize; i++) {
        potential_min->set(min, lower[i]);
        potential_max->set(max, upper[i]);
        ++min;
        ++max;
      }
    }

fillConstraint() [2/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::fillConstraint	(	const NodeId &	id,
		Instantiation	ins,
		const std::vector< GUM_SCALAR > &	lower,
		const std::vector< GUM_SCALAR > &	upper
	)

Set the interval constraints of a credal sets of a given node ( from an instantiation )

Parameters

id	The NodeId of the node
ins	The Instantiation
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefor we pass it by value

Definition at line 311 of file credalNet_tpl.h.

                                                                                       {
      const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(id));
      /*
      auto var_dSize =  _src_bn_.variable ( id ).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;
      */
      // to be sure of entry index reorder ins according to the bayes net
      // potentials
      // ( of the credal net )
      // it WONT throw an error if the sequences are not equal not because of
      // order
      // but content, so we double check (before & after order correction)
      // beware of slaves & master
      Instantiation ref(potential);
      ref.forgetMaster();

      ins.forgetMaster();

      const auto& vseq = ref.variablesSequence();

      if (ins.variablesSequence() != vseq) {
        ins.reorder(ref);

        if (ins.variablesSequence() != vseq)
          GUM_ERROR(OperationNotAllowed,
                    "setCPT : instantiation : "
                       << ins << " is not valid for node id " << id
                       << " which accepts instantiations such as (order is not "
                          "important) : "
                       << ref);
      }

      Idx entry = 0, jump = 1;

      for (Idx i = 0, end = ins.nbrDim(); i < end; i++) {
        if (_src_bn_.nodeId(ins.variable(i)) == id) continue;

        entry += ins.val(i) * jump;

        jump *= ins.variable(i).domainSize();
      }

      /*
      if ( entry >= entry_size )
        GUM_ERROR ( SizeError, "setCPT : entry is greater or equal than entry
      size
      (entries start at 0 up to entry_size - 1) : " << entry << " >= " <<
      entry_size
      );

      if ( lower.size() != var_dSize || upper.size() != var_dSize )
        GUM_ERROR ( SizeError, "setCPT : variable modalities in cpts does not
      match
      for node id : " << id << " with sizes of constraints : ( "<< lower.size()
      << "
      || " << upper.size() << " ) != " << var_dSize );
      */
      fillConstraint(id, entry, lower, upper);
    }

fillConstraints()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::fillConstraints	(	const NodeId &	id,
		const std::vector< GUM_SCALAR > &	lower,
		const std::vector< GUM_SCALAR > &	upper
	)

Set the interval constraints of the credal sets of a given node (all instantiations )

Parameters

id	The NodeId of the node
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 251 of file credalNet_tpl.h.

                                                                                        {
      try {
        _src_bn_min_.cpt(id).fillWith(lower);
        _src_bn_max_.cpt(id).fillWith(upper);
      } catch (const SizeError&) {
        GUM_ERROR(SizeError,
                  "fillConstraints : sizes does not match in fillWith for node id : " << id);
      }
    }

get_binaryCPT_max()

template<typename GUM_SCALAR >

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_binaryCPT_max

(

)

const

Used with binary networks to speed-up L2U inference.

Returns

Returns a constant reference to the upper probabilities of each node X over the "true" modality, i.e. \( \overline{p}(X = 1 \mid pa(X) = j) *\).

Definition at line 1299 of file credalNet_tpl.h.

                                                        {
      return _binCptMax_;
    }

get_binaryCPT_min()

template<typename GUM_SCALAR >

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_binaryCPT_min

(

)

const

Used with binary networks to speed-up L2U inference.

Returns

Returns a constant reference to the lower probabilities of each node X over the "true" modality, i.e. \( \underline{p}(X = 1 \mid pa(X) = j) *\).

Definition at line 1293 of file credalNet_tpl.h.

                                                        {
      return _binCptMin_;
    }

hasComputedBinaryCPTMinMax()

template<typename GUM_SCALAR >

const bool gum::credal::CredalNet< GUM_SCALAR >::hasComputedBinaryCPTMinMax

(

)

const

Returns

Returns TRUE if this CredalNet has called computeBinaryCPTMinMax() to speed-up inference with binary networks and L2U. This needs to be reworked as it is too easy to forget to call it and it can't be called within the inference engine (constness).

Definition at line 1255 of file credalNet_tpl.h.

                                                                         {
      return _hasComputedBinaryCPTMinMax_;
    }

idmLearning()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::idmLearning	(	const Idx	s = 0,
		const bool	keepZeroes = false
	)

Learns parameters from a BayesNet storing counts of events.

Use this method when using a single BayesNet storing counts of events. IDM model if s > 0, standard point probability if s = 0 (default value if none precised).

Parameters

s	The IDM parameter.
keepZeroes	Boolean used as a flag as whether or not - respectively TRUE or FALSE - we keep zeroes as zeroes. Default is FALSE, i.e. zeroes are not kept.

Definition at line 601 of file credalNet_tpl.h.

                                                                                {
      for (auto node: _src_bn_.nodes()) {
        const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(node));

        Potential< GUM_SCALAR >* const potential_min(
           const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_min_.cpt(node)));
        Potential< GUM_SCALAR >* const potential_max(
           const_cast< Potential< GUM_SCALAR >* const >(&_src_bn_max_.cpt(node)));

        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);
        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_max);

        ins.setFirst();
        ins_min.setFirst();
        ins_max.setFirst();

        std::vector< GUM_SCALAR > vertex(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR den = 0;
          Size       nbm = 0;

          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = potential->get(ins);

            if (vertex[modality] < 1 && vertex[modality] > 0)
              GUM_ERROR(OperationNotAllowed,
                        "idmLearning : the BayesNet contains "
                        "probabilities and not event counts.");

            den += vertex[modality];

            if (vertex[modality] > 0) nbm++;

            ++ins;
          }

          if (nbm > 1 || !keepZeroes) den += s;

          GUM_SCALAR min, max;

          for (Size modality = 0; modality < var_dSize; modality++) {
            min = vertex[modality];
            max = min;

            if ((vertex[modality] > 0 && nbm > 1) || !keepZeroes) { max += s; }

            min = GUM_SCALAR(min * 1.0 / den);
            max = GUM_SCALAR(max * 1.0 / den);

            potential_min->set(ins_min, min);
            potential_max->set(ins_max, max);

            ++ins_min;
            ++ins_max;
          }   // end of : for each modality

        }   // end of : for each entry

      }   // end of : for each variable

      _epsilonMin_ = GUM_SCALAR(s);
      _epsilonMax_ = GUM_SCALAR(s);
      _epsilonMoy_ = GUM_SCALAR(s);
      _intervalToCredal_();
    }

instantiation()

template<typename GUM_SCALAR >

INLINE Instantiation gum::credal::CredalNet< GUM_SCALAR >::instantiation

(

const NodeId &

id

)

Get an Instantiation from a node id, usefull to fill the constraints of the network

bnet accessors / shortcuts

Parameters

id	The NodeId we want an instantiation from

Returns

The instantiation

Definition at line 378 of file credalNet_tpl.h.

                                                                                {
      return Instantiation(_src_bn_.cpt(id));
    }

intervalToCredal()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal

(

)

Computes the vertices of each credal set according to their interval definition (uses lrs).

Use this method when using two BayesNet, one with lower probabilities and one with upper probabilities.

Definition at line 767 of file credalNet_tpl.h.

                                                   {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();

      _credalNet_src_cpt_.resize(_src_bn_.size());

      LRSWrapper< GUM_SCALAR > lrsWrapper;

      for (auto node: _src_bn_.nodes()) {
        const Potential< GUM_SCALAR >* const potential_min(&_src_bn_min_.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(&_src_bn_max_.cpt(node));

        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_max);

        ins_min.setFirst();
        ins_max.setFirst();

        lrsWrapper.setUpH(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          for (Size modality = 0; modality < var_dSize; modality++) {
            if (potential_min->get(ins_min) > potential_max->get(ins_max)) {
              GUM_ERROR(CPTError,
                        "For variable "
                           << _src_bn_.variable(node).name() << " (at " << ins_min
                           << "), the min is greater than the max : " << potential_min->get(ins_min)
                           << ">" << potential_max->get(ins_max) << ".");
            }
            lrsWrapper.fillH(potential_min->get(ins_min), potential_max->get(ins_max), modality);
            ++ins_min;
            ++ins_max;
          }

          lrsWrapper.H2V();
          var_cpt[entry] = lrsWrapper.getOutput();
          lrsWrapper.nextHInput();
        }

        _credalNet_src_cpt_.insert(node, var_cpt);

      }   // end of : for each variable (node)

      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

intervalToCredalWithFiles()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::intervalToCredalWithFiles

(

)

Deprecated:

Use intervalToCredal ( lrsWrapper with no input / output files needed ).

Computes the vertices of each credal set according to their interval definition (uses lrs).

Use this method when using a single BayesNet storing counts of events.

Definition at line 821 of file credalNet_tpl.h.

                                                            {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();

      _credalNet_src_cpt_.resize(_src_bn_.size());

      for (auto node: _src_bn_.nodes()) {
        const Potential< GUM_SCALAR >* const potential_min(&_src_bn_min_.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(&_src_bn_max_.cpt(node));

        auto var_dSize  = _src_bn_.variable(node).domainSize();
        auto entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_max);

        ins_min.setFirst();
        ins_max.setFirst();

        // use iterator
        for (Size entry = 0; entry < entry_size; entry++) {
          std::vector< std::vector< GUM_SCALAR > > vertices;
          std::vector< GUM_SCALAR >                vertex(var_dSize);   // if not interval

          std::vector< std::vector< GUM_SCALAR > > inequalities(
             var_dSize * 2,
             std::vector< GUM_SCALAR >(var_dSize + 1, 0));

          std::vector< GUM_SCALAR > sum_ineq1(var_dSize + 1, -1);
          std::vector< GUM_SCALAR > sum_ineq2(var_dSize + 1, 1);
          sum_ineq1[0] = 1;
          sum_ineq2[0] = -1;

          bool isInterval = false;

          for (Size modality = 0; modality < var_dSize; modality++) {
            inequalities[modality * 2][0]                = -potential_min->get(ins_min);
            inequalities[modality * 2 + 1][0]            = potential_max->get(ins_max);
            inequalities[modality * 2][modality + 1]     = 1;
            inequalities[modality * 2 + 1][modality + 1] = -1;

            vertex[modality] = inequalities[modality * 2 + 1][0];

            if (!isInterval
                && (-inequalities[modality * 2][0] != inequalities[modality * 2 + 1][0]))
              isInterval = true;

            ++ins_min;
            ++ins_max;
          }

          inequalities.push_back(sum_ineq1);
          inequalities.push_back(sum_ineq2);

          if (!isInterval) {
            vertices.push_back(vertex);
          } else {
            try {
              _H2Vlrs_(inequalities, vertices);
              // __H2Vcdd ( inequalities, vertices );
            } catch (const std::exception& err) {
              std::cout << err.what() << std::endl;
              throw;
            }

          }   // end of : is interval

          if (entry == 0 && vertices.size() >= 2) {
            auto tmp    = vertices[0];
            vertices[0] = vertices[1];
            vertices[1] = tmp;
          }

          var_cpt[entry] = vertices;

        }   // end of : for each entry

        _credalNet_src_cpt_.insert(node, var_cpt);
        // std::cout <<  _src_bn_.variable(node_idIt).name() << std::endl;
        // std::cout << var_cpt << std::endl;

      }   // end of : for each variable (node)

      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

isSeparatelySpecified()

template<typename GUM_SCALAR >

const bool gum::credal::CredalNet< GUM_SCALAR >::isSeparatelySpecified

(

)

const

Returns

Returns TRUE if this CredalNet is separately and interval specified, FALSE otherwise.

Definition at line 1250 of file credalNet_tpl.h.

                                                                    {
      return _separatelySpecified_;
    }

lagrangeNormalization()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::lagrangeNormalization

(

)

Normalize counts of a BayesNet storing counts of each events such that no probability is 0.

Use this method when using a single BayesNet storing counts of events. Lagrange normalization. This call is irreversible and modify counts stored by src_bn.

Doest not performs computations of the parameters but keeps normalized counts of events only. Call idmLearning to compute the probabilities (with any parameter value).

Definition at line 552 of file credalNet_tpl.h.

                                                        {
      for (auto node: _src_bn_.nodes()) {
        const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(node));

        auto var_dSize  = _src_bn_.variable(node).domainSize();
        auto entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);

        ins.setFirst();

        std::vector< GUM_SCALAR > vertex(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR    den      = 0;
          bool          zeroes   = false;
          Instantiation ins_prev = ins;

          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = potential->get(ins);

            if (vertex[modality] < 1 && vertex[modality] > 0)
              GUM_ERROR(OperationNotAllowed,
                        "lagrangeNormalization : the BayesNet "
                        "contains probabilities and not event "
                        "counts.");

            den += vertex[modality];

            if (!zeroes && vertex[modality] == 0) { zeroes = true; }

            ++ins;
          }

          if (zeroes) {
            ins = ins_prev;

            for (Size modality = 0; modality < var_dSize; modality++) {
              potential->set(ins, potential->get(ins) + 1);
              ++ins;
            }
          }

        }   // end of : for each entry

      }   // end of : for each variable
    }

nodeType()

template<typename GUM_SCALAR >

CredalNet< GUM_SCALAR >::NodeType gum::credal::CredalNet< GUM_SCALAR >::nodeType

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the choosen NodeId

Returns

Returns the type of the choosen node in the ( up-to-date ) CredalNet in src_bn.

Definition at line 1245 of file credalNet_tpl.h.

                                                               {
      return _original_nodeType_[id];
    }

saveBNsMinMax()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::saveBNsMinMax	(	const std::string &	min_path,
		const std::string &	max_path
	)		const

If this CredalNet was built over a perturbed BayesNet, one can save the intervals as two BayesNet.

to call after bnToCredal( GUM_SCALAR beta ) save a BN with lower probabilities and a BN with upper ones

Parameters

min_path	The path to save the BayesNet which contains the lower probabilities of each node X, i.e. \( \underline{p}(X = i \mid pa(X) = *j) *\).
max_path	The path to save the BayesNet which contains the upper probabilities of each node X, i.e. \( \overline{p}(X = i \mid pa(X) = *j) *\).

Definition at line 915 of file credalNet_tpl.h.

                                                                                 {
      BIFWriter< GUM_SCALAR > writer;

      std::string   minfilename = min_path;   //"min.bif";
      std::string   maxfilename = max_path;   //"max.bif";
      std::ofstream min_file(minfilename.c_str(), std::ios::out | std::ios::trunc);
      std::ofstream max_file(maxfilename.c_str(), std::ios::out | std::ios::trunc);

      if (!min_file.good())
        GUM_ERROR(IOError, "bnToCredal() : could not open stream : min_file : " << minfilename);

      if (!max_file.good()) {
        min_file.close();
        GUM_ERROR(IOError, "bnToCredal() : could not open stream : min_file : " << maxfilename);
      }

      try {
        writer.write(min_file, _src_bn_min_);
        writer.write(max_file, _src_bn_max_);
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        min_file.close();
        max_file.close();
        throw(err);
      }

      min_file.close();
      max_file.close();
    }

setCPT() [1/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::setCPT	(	const NodeId &	id,
		Size &	entry,
		const std::vector< std::vector< GUM_SCALAR > > &	cpt
	)

Set the vertices of one credal set of a given node ( any instantiation index )

Parameters

id	The NodeId of the node
entry	The index of the instantiation ( from 0 to K - 1 ) excluding the given node ( only the parents are used to compute the index of the credal set )
cpt	The vertices of every credal set ( for each instantiation of the parents )

Use this with either LRSWrapper or LpInterface to get the vertices of a credal set represented by linear constraints.

Warning

: Does not change the BayesNet (s) associated to this credal net !

Definition at line 110 of file credalNet_tpl.h.

                                                                                          {
      const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(id));

      auto var_dSize  = _src_bn_.variable(id).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;

      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                     << entry << " >= " << entry_size);

      if (cpt.size() == 0) GUM_ERROR(SizeError, "setCPT : empty credal set for entry : " << entry)

      for (const auto& vertex: cpt) {
        if (vertex.size() != var_dSize)
          GUM_ERROR(SizeError,
                    "setCPT : variable modalities in cpts does not "
                    "match for node id : "
                       << id << " with vertex " << vertex << " at entry " << entry << " : "
                       << vertex.size() << " != " << var_dSize);

        GUM_SCALAR sum = 0;

        for (const auto& prob: vertex) {
          sum += prob;
        }

        if (std::fabs(sum - 1) > 1e-6)
          GUM_ERROR(CPTNoSumTo1,
                    "setCPT : a vertex coordinates does not sum to one for node id : "
                       << id << " at entry " << entry << " with vertex " << vertex);
      }

      // !! auto does NOT use adress (if available) unless explicitly asked !!
      auto& node_cpt = _credalNet_src_cpt_.getWithDefault(
         id,
         std::vector< std::vector< std::vector< GUM_SCALAR > > >(entry_size));

      if (node_cpt[entry].size() != 0)
        GUM_ERROR(DuplicateElement,
                  "setCPT : vertices of entry id " << entry
                                                   << " already set to : " << node_cpt[entry]
                                                   << ", cannot insert : " << cpt);

      node_cpt[entry] = cpt;

    }

setCPT() [2/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::setCPT	(	const NodeId &	id,
		Instantiation	ins,
		const std::vector< std::vector< GUM_SCALAR > > &	cpt
	)

Set the vertices of one credal set of a given node ( any instantiation )

Parameters

id	The NodeId of the node
ins	The Instantiation ( only the parents matter to find the credal set index )
cpt	The vertices of every credal set ( for each instantiation of the parents )

Use this with either LRSWrapper or LpInterface to get the vertices of a credal set represented by linear constraints.

Warning

: Does not change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefor we pass it by value

Definition at line 163 of file credalNet_tpl.h.

                                                                                          {
      const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(id));

      auto var_dSize  = _src_bn_.variable(id).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;

      // to be sure of entry index reorder ins according to the bayes net
      // potentials
      // ( of the credal net )
      // it WONT throw an error if the sequences are not equal not because of
      // order
      // but content, so we double check (before & after order correction)
      // beware of slaves & master
      Instantiation ref(potential);
      ref.forgetMaster();

      ins.forgetMaster();

      const auto& vseq = ref.variablesSequence();

      if (ins.variablesSequence() != vseq) {
        ins.reorder(ref);

        if (ins.variablesSequence() != vseq)
          GUM_ERROR(OperationNotAllowed,
                    "setCPT : instantiation : "
                       << ins << " is not valid for node id " << id
                       << " which accepts instantiations such as (order is not "
                          "important) : "
                       << ref);
      }

      Idx entry = 0, jump = 1;

      for (Idx i = 0, end = ins.nbrDim(); i < end; i++) {
        if (_src_bn_.nodeId(ins.variable(i)) == id) continue;

        entry += ins.val(i) * jump;

        jump *= ins.variable(i).domainSize();
      }

      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                     << entry << " >= " << entry_size);

      if (cpt.size() == 0) GUM_ERROR(SizeError, "setCPT : empty credal set for entry : " << entry)

      for (const auto& vertex: cpt) {
        if (vertex.size() != var_dSize)
          GUM_ERROR(SizeError,
                    "setCPT : variable modalities in cpts does not "
                    "match for node id : "
                       << id << " with vertex " << vertex << " at entry " << entry << " : "
                       << vertex.size() << " != " << var_dSize);

        GUM_SCALAR sum = 0;

        for (const auto& prob: vertex) {
          sum += prob;
        }

        if (std::fabs(sum - 1) > 1e-6)
          GUM_ERROR(CPTNoSumTo1,
                    "setCPT : a vertex coordinates does not sum to one for node id : "
                       << id << " at entry " << entry << " with vertex " << vertex);
      }

      auto& node_cpt = _credalNet_src_cpt_.getWithDefault(
         id,
         std::vector< std::vector< std::vector< GUM_SCALAR > > >(entry_size));

      if (node_cpt[entry].size() != 0)
        GUM_ERROR(DuplicateElement,
                  "setCPT : vertices of entry : " << ins << " id " << entry
                                                  << " already set to : " << node_cpt[entry]
                                                  << ", cannot insert : " << cpt);

      node_cpt[entry] = cpt;

    }

setCPTs()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::setCPTs	(	const NodeId &	id,
		const std::vector< std::vector< std::vector< GUM_SCALAR > > > &	cpt
	)

Set the vertices of the credal sets ( all of the conditionals ) of a given node

Parameters

id	The NodeId of the node
cpt	The vertices of every credal set ( for each instantiation of the parents )

Warning

: Does not change the BayesNet (s) associated to this credal net !

First dimension is instantiation position ( from 0 to K - 1 ). Second is the credal set vertice index Third is the vertex

Definition at line 65 of file credalNet_tpl.h.

                                                                     {
      const Potential< GUM_SCALAR >* const potential(&_src_bn_.cpt(id));

      auto var_dSize  = _src_bn_.variable(id).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;

      if (cpt.size() != entry_size)
        GUM_ERROR(SizeError,
                  "setCPTs : entry sizes of cpts does not match for node id : "
                     << id << " : " << cpt.size() << " != " << entry_size);

      for (const auto& cset: cpt) {
        if (cset.size() == 0)
          GUM_ERROR(SizeError,
                    "setCPTs : vertices in credal set does not match for node id : "
                       << id << " with 0 vertices");

        for (const auto& vertex: cset) {
          if (vertex.size() != var_dSize)
            GUM_ERROR(SizeError,
                      "setCPTs : variable modalities in cpts does "
                      "not match for node id : "
                         << id << " with vertex " << vertex << " : " << vertex.size()
                         << " != " << var_dSize);

          GUM_SCALAR sum = 0;

          for (const auto& prob: vertex) {
            sum += prob;
          }

          if (std::fabs(sum - 1) > 1e-6)
            GUM_ERROR(CPTNoSumTo1,
                      "setCPTs : a vertex coordinates does not "
                      "sum to one for node id : "
                         << id << " with vertex " << vertex);
        }
      }

      _credalNet_src_cpt_.insert(id, cpt);
    }

src_bn()

template<typename GUM_SCALAR >

const BayesNet< GUM_SCALAR > & gum::credal::CredalNet< GUM_SCALAR >::src_bn

(

)

const

Returns

Returns a constant reference to the original BayesNet (used as a DAG, it's CPTs does not matter).

Definition at line 1367 of file credalNet_tpl.h.

                                                                        {
      return _src_bn_;
    }

toString()

template<typename GUM_SCALAR >

std::string gum::credal::CredalNet< GUM_SCALAR >::toString

(

)

const

Returns

Returns the string representation of this CredalNet, i.e. it's CPTs (which also represent arcs).

Definition at line 1319 of file credalNet_tpl.h.

                                                      {
      std::stringstream             output;
      const BayesNet< GUM_SCALAR >* _current_bn_;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
         _credalNet_current_cpt_;

      if (this->_current_bn_ == nullptr)
        _current_bn_ = &this->_src_bn_;
      else
        _current_bn_ = this->_current_bn_;

      if (this->_credalNet_current_cpt_ == nullptr)
        _credalNet_current_cpt_ = &this->_credalNet_src_cpt_;
      else
        _credalNet_current_cpt_ = this->_credalNet_current_cpt_;

      for (auto node: _current_bn_->nodes()) {
        const Potential< GUM_SCALAR >* potential(&_current_bn_->cpt(node));
        auto pconfs = potential->domainSize() / _current_bn_->variable(node).domainSize();

        output << "\n" << _current_bn_->variable(node) << "\n";

        Instantiation ins(potential);
        ins.forgetMaster();
        ins.erase(_current_bn_->variable(node));
        ins.setFirst();

        for (Size pconf = 0; pconf < pconfs; pconf++) {
          output << ins << " : ";
          output << (*_credalNet_current_cpt_)[node][pconf] << "\n";

          if (pconf < pconfs - 1) ++ins;
        }
      }

      output << "\n";

      return output.str();
    }

Member Data Documentation

_binCptMax_

template<typename GUM_SCALAR >

std::vector< std::vector< GUM_SCALAR > > gum::credal::CredalNet< GUM_SCALAR >::_binCptMax_

private

Used with binary networks to speed-up L2U inference.

Store the upper probabilities of each node X over the "true" modality, i.e. \( \overline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 627 of file credalNet.h.

_binCptMin_

template<typename GUM_SCALAR >

std::vector< std::vector< GUM_SCALAR > > gum::credal::CredalNet< GUM_SCALAR >::_binCptMin_

private

Used with binary networks to speed-up L2U inference.

Store the lower probabilities of each node X over the "true" modality, i.e. \( \underline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 619 of file credalNet.h.

_credalNet_current_cpt_

template<typename GUM_SCALAR >

NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >* gum::credal::CredalNet< GUM_SCALAR >::_credalNet_current_cpt_

private

This CredalNet up-to-date CPTs.

Definition at line 600 of file credalNet.h.

_credalNet_src_cpt_

template<typename GUM_SCALAR >

NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > gum::credal::CredalNet< GUM_SCALAR >::_credalNet_src_cpt_

private

This CredalNet original CPTs.

Definition at line 596 of file credalNet.h.

_current_bn_

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR >* gum::credal::CredalNet< GUM_SCALAR >::_current_bn_

private

Up-to-date BayesNet (used as a DAG).

Definition at line 593 of file credalNet.h.

_current_nodeType_

template<typename GUM_SCALAR >

NodeProperty< NodeType >* gum::credal::CredalNet< GUM_SCALAR >::_current_nodeType_

private

The NodeType of each node from the up-to-date network.

Definition at line 608 of file credalNet.h.

_deltaC_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_deltaC_

private

5 by default, used by fracC as number of decimals.

Definition at line 547 of file credalNet.h.

_denMax_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_denMax_

private

Highest possible denominator allowed when using farey.

A value too high may lead to lrs being unable to find vertices.

Definition at line 574 of file credalNet.h.

_epsF_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsF_

private

Value under which a decimal number is considered to be zero when using farey.

Definition at line 570 of file credalNet.h.

_epsilonMax_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMax_

private

The highest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 556 of file credalNet.h.

_epsilonMin_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMin_

private

The lowest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 552 of file credalNet.h.

_epsilonMoy_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMoy_

private

The average perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 560 of file credalNet.h.

_epsRedund_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsRedund_

private

Value under which a decimal number is considered to be zero when computing redundant vertices.

Definition at line 565 of file credalNet.h.

_hasComputedBinaryCPTMinMax_

template<typename GUM_SCALAR >

bool gum::credal::CredalNet< GUM_SCALAR >::_hasComputedBinaryCPTMinMax_

private

Used by L2U, to know if lower and upper probabilities over the second modality has been stored in order to speed-up the algorithm.

Definition at line 612 of file credalNet.h.

_original_nodeType_

template<typename GUM_SCALAR >

NodeProperty< NodeType > gum::credal::CredalNet< GUM_SCALAR >::_original_nodeType_

private

The NodeType of each node from the ORIGINAL network.

Definition at line 606 of file credalNet.h.

_precision_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_precision_

private

Precision used by frac.

Definition at line 577 of file credalNet.h.

_precisionC_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_precisionC_

private

1e6 by default, used by fracC as precision.

Definition at line 545 of file credalNet.h.

_separatelySpecified_

template<typename GUM_SCALAR >

bool gum::credal::CredalNet< GUM_SCALAR >::_separatelySpecified_

private

TRUE if this CredalNet is separately and interval specified, FALSE otherwise.

Definition at line 582 of file credalNet.h.

_src_bn_

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_

private

Original BayesNet (used as a DAG).

Is never modified.

Definition at line 585 of file credalNet.h.

_src_bn_max_

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_max_

private

BayesNet used to store upper probabilities.

Definition at line 590 of file credalNet.h.

_src_bn_min_

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_min_

private

BayesNet used to store lower probabilities.

Definition at line 588 of file credalNet.h.

_var_bits_

template<typename GUM_SCALAR >

NodeProperty< std::vector< NodeId > > gum::credal::CredalNet< GUM_SCALAR >::_var_bits_

private

Corresponding bits of each variable.

Deprecated:

Definition at line 603 of file credalNet.h.

---

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

• agrum/CN/credalNet.h
• agrum/CN/credalNet_tpl.h