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	computeCPTMinMax ()
	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	hasComputedCPTMinMax () const
const std::vector< std::vector< GUM_SCALAR > > &	get_CPT_min () const
	Used with binary networks to speed-up L2U inference. More...
const std::vector< std::vector< GUM_SCALAR > > &	get_CPT_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 89 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 92 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 402 of file credalNet_tpl.h.

References GUM_SHOWERROR.

                                                                     {
      try {
        __initParams();
        __initCNNets(src_min_num, src_max_den);
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        throw(err);
      }

      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 416 of file credalNet_tpl.h.

References GUM_SHOWERROR.

                                                                                  {
      try {
        __initParams();
        __initCNNets(src_min_num, src_max_den);
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        throw(err);
      }

      GUM_CONSTRUCTOR(CredalNet);
    }

~CredalNet()

template<typename GUM_SCALAR >

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

(

)

Destructor.

Definition at line 430 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 1512 of file credalNet_tpl.h.

References gum::BayesNet< GUM_SCALAR >::add(), gum::BayesNet< GUM_SCALAR >::addArc(), gum::BayesNet< GUM_SCALAR >::beginTopologyTransformation(), gum::BayesNet< GUM_SCALAR >::cpt(), gum::BayesNet< GUM_SCALAR >::endTopologyTransformation(), gum::BayesNet< GUM_SCALAR >::nodeId(), gum::DAGmodel::nodes(), and gum::BayesNet< GUM_SCALAR >::variable().

                                                                       {
      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();
    }

Here is the call graph for this function:

__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 1498 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 1588 of file credalNet_tpl.h.

References gum::Rational< GUM_SCALAR >::farey(), gum::getNumberOfRunningThreads(), gum::getThreadNumber(), gum::getUniqueFileName(), and GUM_ERROR.

                                                                {
      // 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);
    }

Here is the call graph for this function:

__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 1449 of file credalNet_tpl.h.

References GUM_SHOWERROR, and gum::BIFReader< GUM_SCALAR >::proceed().

                                                                             {
      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);

      try {
        reader.proceed();
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        throw(err);
      }

      try {
        reader_min.proceed();
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        throw(err);
      }

      try {
        reader_max.proceed();
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        throw(err);
      }
    }

Here is the call graph for this function:

__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 1485 of file credalNet_tpl.h.

References gum::DAGmodel::size().

                                                  {
      __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;
    }

Here is the call graph for this function:

__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 1422 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;

      __hasComputedCPTMinMax = 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 697 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                     {
      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;
    }

Here is the call graph for this function:

__sort_varType()

template<typename GUM_SCALAR >

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

private

Set the NodeType of each node

Definition at line 1778 of file credalNet_tpl.h.

References gum::HashTable< Key, Val, Alloc >::exists(), gum::HashTable< Key, Val, Alloc >::insert(), gum::DAGmodel::nodes(), and gum::HashTable< Key, Val, Alloc >::size().

                                                 {
      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
    }

Here is the call graph for this function:

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 59 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.

References GUM_ERROR.

                                                                         {
      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 orignal credal sets and may induce huge imprecision.

Warning

Enlarge the orignal credal sets and therefor induce huge imprecision by propagation. Not recommanded, use MCSampling or something else instead.

Definition at line 979 of file credalNet_tpl.h.

References gum::BayesNet< GUM_SCALAR >::add(), gum::BayesNet< GUM_SCALAR >::addArc(), gum::BayesNet< GUM_SCALAR >::beginTopologyTransformation(), gum::HashTable< Key, Val, Alloc >::clear(), gum::BayesNet< GUM_SCALAR >::cpt(), gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), gum::Set< Key, Alloc >::empty(), gum::BayesNet< GUM_SCALAR >::endTopologyTransformation(), gum::int2Pow(), gum::MultiDimDecorator< GUM_SCALAR >::pos(), gum::HashTable< Key, Val, Alloc >::size(), gum::superiorPow(), and gum::BayesNet< GUM_SCALAR >::variable().

                                                           {
      // don't forget to delete the old one (__current), if necessary at the end
      BayesNet< GUM_SCALAR >* __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
      NodeProperty< NodeType >* __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() + " - bit - ";
            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::string s;
          s = "I-";
          std::stringstream ss;
          ss << __src_bn.variable(i).name();
          ss << "-";
          ss << mod;
          s += ss.str();

          LabelizedVariable var(s, "node " + s, 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 (i == 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
    }

Here is the call graph for this function:

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 442 of file credalNet_tpl.h.

References gum::MultiDimDecorator< GUM_SCALAR >::get(), GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::set(), and gum::Instantiation::setFirst().

                                                                          {
      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();
    }

Here is the call graph for this function:

computeCPTMinMax()

template<typename GUM_SCALAR >

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

(

)

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 1305 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;
      }

      __hasComputedCPTMinMax = 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 1267 of file credalNet_tpl.h.

Referenced by gum::credal::VarMod2BNsMap< GUM_SCALAR >::setCNet().

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

      return __credalNet_src_cpt;
    }

Here is the caller graph for this function:

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 1275 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 1406 of file credalNet_tpl.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::CNLoopyPropagation().

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

      return __src_bn;
    }

Here is the caller graph for this function:

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 1281 of file credalNet_tpl.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::_makeInferenceByOrderedArcs(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::_makeInferenceByRandomOrder().

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

      return __original_nodeType[id];
    }

Here is the caller graph for this function:

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 395 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 1353 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 1358 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 1348 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 ), therefor we pass it by value

Definition at line 273 of file credalNet_tpl.h.

References gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::set(), and gum::Instantiation::setFirst().

                                             {
      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;
      }
    }

Here is the call graph for this function:

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 322 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), gum::Instantiation::forgetMaster(), GUM_ERROR, gum::Instantiation::nbrDim(), gum::Instantiation::reorder(), gum::Instantiation::val(), gum::Instantiation::variable(), gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence(), and gum::Instantiation::variablesSequence().

                                             {
      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);
    }

Here is the call graph for this function:

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 ), therefor we pass it by value

Definition at line 257 of file credalNet_tpl.h.

References GUM_ERROR.

                                             {
      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_CPT_max()

template<typename GUM_SCALAR >

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_CPT_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 1343 of file credalNet_tpl.h.

                                                  {
      return __binCptMax;
    }

get_CPT_min()

template<typename GUM_SCALAR >

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_CPT_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 1337 of file credalNet_tpl.h.

                                                  {
      return __binCptMin;
    }

hasComputedCPTMinMax()

template<typename GUM_SCALAR >

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

(

)

const

Returns

Returns TRUE if this CredalNet has called computeCPTMinMax() 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 1299 of file credalNet_tpl.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::CNLoopyPropagation().

                                                                   {
      return __hasComputedCPTMinMax;
    }

Here is the caller graph for this function:

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 624 of file credalNet_tpl.h.

References GUM_ERROR, gum::MultiDimDecorator< GUM_SCALAR >::set(), and gum::Instantiation::setFirst().

                                                                                {
      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();
    }

Here is the call graph for this function:

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 390 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 794 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), gum::credal::LRSWrapper< GUM_SCALAR >::fillH(), gum::credal::LRSWrapper< GUM_SCALAR >::getOutput(), gum::credal::LRSWrapper< GUM_SCALAR >::H2V(), gum::credal::LRSWrapper< GUM_SCALAR >::nextHInput(), gum::Instantiation::setFirst(), gum::credal::LRSWrapper< GUM_SCALAR >::setUpH(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                   {
      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++) {
            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;
    }

Here is the call graph for this function:

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 845 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                            {
      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;
    }

Here is the call graph for this function:

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 1294 of file credalNet_tpl.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::CNLoopyPropagation().

                                                                    {
      return __separatelySpecified;
    }

Here is the caller graph for this function:

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 575 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Instantiation::setFirst(), and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                        {
      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
    }

Here is the call graph for this function:

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 1289 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 943 of file credalNet_tpl.h.

References GUM_ERROR, GUM_SHOWERROR, and gum::BIFWriter< GUM_SCALAR >::write().

                                                                               {
      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();
    }

Here is the call graph for this function:

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 112 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), GUM_ERROR, and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                        {
      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;

    }

Here is the call graph for this function:

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 167 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), gum::Instantiation::forgetMaster(), GUM_ERROR, gum::Instantiation::nbrDim(), gum::Instantiation::reorder(), gum::Instantiation::val(), gum::MultiDimDecorator< GUM_SCALAR >::variable(), gum::Instantiation::variable(), and gum::Instantiation::variablesSequence().

                                                        {
      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;

    }

Here is the call graph for this function:

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 66 of file credalNet_tpl.h.

References gum::DiscreteVariable::domainSize(), GUM_ERROR, and gum::MultiDimDecorator< GUM_SCALAR >::variable().

                                                                     {
      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);
    }

Here is the call graph for this function:

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 1413 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 1363 of file credalNet_tpl.h.

References gum::BayesNet< GUM_SCALAR >::cpt(), gum::MultiDimDecorator< GUM_SCALAR >::domainSize(), gum::Instantiation::erase(), gum::Instantiation::forgetMaster(), gum::DAGmodel::nodes(), gum::Instantiation::setFirst(), and gum::BayesNet< GUM_SCALAR >::variable().

                                                      {
      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();
    }

Here is the call graph for this function:

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 664 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 656 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 637 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 633 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 629 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 645 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 583 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 610 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 606 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 592 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 588 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 596 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 601 of file credalNet.h.

__hasComputedCPTMinMax

template<typename GUM_SCALAR>

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

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 649 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 643 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 613 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 581 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 618 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 621 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 626 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 624 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 640 of file credalNet.h.

---

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

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