aGrUM  0.20.2
a C++ library for (probabilistic) graphical models
MarkovNet_tpl.h
Go to the documentation of this file.
1 /**
2  *
3  * Copyright 2005-2020 Pierre-Henri WUILLEMIN(@LIP6) et Christophe GONZALES(@AMU)
4  * (@AMU) info_at_agrum_dot_org
5  *
6  * This library is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this library. If not, see <http://www.gnu.org/licenses/>.
18  *
19  */
20 
21 
22 /**
23  * @file
24  * @brief Template implementation of BN/MarkovNet.h class.
25  *
26  * @author Pierre-Henri WUILLEMIN(@LIP6) & Christophe GONZALES(@AMU)
27  */
28 
29 #include <limits>
30 #include <set>
31 
32 #include <agrum/MN/MarkovNet.h>
33 
34 #include <agrum/tools/variables/rangeVariable.h>
35 #include <agrum/tools/variables/labelizedVariable.h>
36 #include <agrum/tools/variables/discretizedVariable.h>
37 
38 #include <agrum/tools/multidim/aggregators/amplitude.h>
39 #include <agrum/tools/multidim/aggregators/and.h>
40 #include <agrum/tools/multidim/aggregators/count.h>
41 #include <agrum/tools/multidim/aggregators/exists.h>
42 #include <agrum/tools/multidim/aggregators/forall.h>
43 #include <agrum/tools/multidim/aggregators/max.h>
44 #include <agrum/tools/multidim/aggregators/median.h>
45 #include <agrum/tools/multidim/aggregators/min.h>
46 #include <agrum/tools/multidim/aggregators/or.h>
47 
48 #include <agrum/tools/multidim/ICIModels/multiDimNoisyAND.h>
49 #include <agrum/tools/multidim/ICIModels/multiDimNoisyORCompound.h>
50 #include <agrum/tools/multidim/ICIModels/multiDimNoisyORNet.h>
51 
52 #include <agrum/tools/multidim/ICIModels/multiDimLogit.h>
53 
54 #include <agrum/BN/generator/simpleCPTGenerator.h>
55 #include <agrum/tools/core/utils_string.h>
56 
57 namespace gum {
58  template < typename GUM_SCALAR >
59  NodeId build_node_for_MN(MarkovNet< GUM_SCALAR >& mn,
60  std::string node,
61  Size default_domain_size) {
62  std::string name = node;
63  auto ds = default_domain_size;
64  long range_min = 0;
65  long range_max = long(ds) - 1;
66  std::vector< std::string > labels;
67  std::vector< GUM_SCALAR > ticks;
68 
69  if (*(node.rbegin()) == ']') {
70  auto posBrack = node.find('[');
71  if (posBrack != std::string::npos) {
72  name = node.substr(0, posBrack);
73  const auto& s_args = node.substr(posBrack + 1, node.size() - posBrack - 2);
74  const auto& args = split(s_args, ",");
75  if (args.size() == 0) { // n[]
76  GUM_ERROR(InvalidArgument, "Empty range for variable " << node)
77  } else if (args.size() == 1) { // n[4]
78  ds = static_cast< Size >(std::stoi(args[0]));
79  range_min = 0;
80  range_max = long(ds) - 1;
81  } else if (args.size() == 2) { // n[5,10]
82  range_min = std::stol(args[0]);
83  range_max = std::stol(args[1]);
84  if (1 + range_max - range_min < 2) {
85  GUM_ERROR(InvalidArgument, "Invalid range for variable " << node);
86  }
87  ds = static_cast< Size >(1 + range_max - range_min);
88  } else { // n[3.14,5,10,12]
89  for (const auto& tick: args) {
90  ticks.push_back(static_cast< GUM_SCALAR >(std::atof(tick.c_str())));
91  }
92  ds = static_cast< Size >(args.size() - 1);
93  }
94  }
95  } else if (*(node.rbegin()) == '}') { // node like "n{one|two|three}"
96  auto posBrack = node.find('{');
97  if (posBrack != std::string::npos) {
98  name = node.substr(0, posBrack);
99  labels = split(node.substr(posBrack + 1, node.size() - posBrack - 2), "|");
100  if (labels.size() < 2) {
101  GUM_ERROR(InvalidArgument, "Not enough labels in node " << node);
102  }
103  if (!hasUniqueElts(labels)) {
104  GUM_ERROR(InvalidArgument, "Duplicate labels in node " << node);
105  }
106  ds = static_cast< Size >(labels.size());
107  }
108  }
109 
110  if (ds == 0) {
111  GUM_ERROR(InvalidArgument, "No value for variable " << name << ".");
112  } else if (ds == 1) {
113  GUM_ERROR(InvalidArgument,
114  "Only one value for variable " << name
115  << " (2 at least are needed).");
116  }
117 
118  // now we add the node in the BN
119  NodeId idVar;
120  try {
121  idVar = mn.idFromName(name);
122  } catch (NotFound&) {
123  if (!labels.empty()) {
124  idVar = mn.add(LabelizedVariable(name, name, labels));
125  } else if (!ticks.empty()) {
126  idVar = mn.add(DiscretizedVariable< GUM_SCALAR >(name, name, ticks));
127  } else {
128  idVar = mn.add(RangeVariable(name, name, range_min, range_max));
129  }
130  }
131 
132  return idVar;
133  }
134 
135  template < typename GUM_SCALAR >
136  MarkovNet< GUM_SCALAR >
137  MarkovNet< GUM_SCALAR >::fastPrototype(const std::string& dotlike,
138  Size domainSize) {
139  MarkovNet< GUM_SCALAR > mn;
140 
141 
142  for (const auto& clikchain: split(dotlike, ";")) {
143  NodeSet cliq;
144  for (const auto& node: split(clikchain, "-")) {
145  auto idVar = build_node_for_MN(mn, node, domainSize);
146  cliq.insert(idVar);
147  }
148  mn.addFactor(cliq);
149  }
150  mn.generateFactors();
151  mn.setProperty("name", "fastPrototype");
152  return mn;
153  }
154 
155  template < typename GUM_SCALAR >
156  MarkovNet< GUM_SCALAR >
157  MarkovNet< GUM_SCALAR >::fromBN(const BayesNet< GUM_SCALAR >& bn) {
158  MarkovNet< GUM_SCALAR > mn;
159  for (NodeId nod: bn.nodes()) {
160  mn.add(bn.variable(nod), nod);
161  }
162  mn.beginTopologyTransformation();
163  for (NodeId nod: bn.nodes()) {
164  mn.addFactor(bn.cpt(nod));
165  }
166  mn.endTopologyTransformation();
167  mn.setProperty("name", bn.propertyWithDefault("name", "noname"));
168  return mn;
169  }
170 
171  template < typename GUM_SCALAR >
172  INLINE MarkovNet< GUM_SCALAR >::MarkovNet() :
173  IMarkovNet< GUM_SCALAR >(), topologyTransformationInProgress__(false) {
174  GUM_CONSTRUCTOR(MarkovNet);
175  }
176 
177  template < typename GUM_SCALAR >
178  INLINE MarkovNet< GUM_SCALAR >::MarkovNet(std::string name) :
179  IMarkovNet< GUM_SCALAR >(name), topologyTransformationInProgress__(false) {
180  GUM_CONSTRUCTOR(MarkovNet);
181  }
182 
183  template < typename GUM_SCALAR >
184  MarkovNet< GUM_SCALAR >::MarkovNet(const MarkovNet< GUM_SCALAR >& source) :
185  IMarkovNet< GUM_SCALAR >(source), topologyTransformationInProgress__(false),
186  varMap__(source.varMap__) {
187  GUM_CONS_CPY(MarkovNet);
188  copyFactors__(source);
189  }
190 
191  template < typename GUM_SCALAR >
192  MarkovNet< GUM_SCALAR >&
193  MarkovNet< GUM_SCALAR >::operator=(const MarkovNet< GUM_SCALAR >& source) {
194  if (this != &source) {
195  IMarkovNet< GUM_SCALAR >::operator =(source);
196  varMap__ = source.varMap__;
197  topologyTransformationInProgress__ = false;
198  copyFactors__(source);
199  }
200 
201  return *this;
202  }
203 
204  template < typename GUM_SCALAR >
205  MarkovNet< GUM_SCALAR >::~MarkovNet() {
206  clearFactors__();
207  GUM_DESTRUCTOR(MarkovNet);
208  }
209 
210  template < typename GUM_SCALAR >
211  INLINE const DiscreteVariable&
212  MarkovNet< GUM_SCALAR >::variable(NodeId id) const {
213  return varMap__.get(id);
214  }
215 
216  template < typename GUM_SCALAR >
217  INLINE void
218  MarkovNet< GUM_SCALAR >::changeVariableName(NodeId id,
219  const std::string& new_name) {
220  varMap__.changeName(id, new_name);
221  }
222 
223  template < typename GUM_SCALAR >
224  INLINE void
225  MarkovNet< GUM_SCALAR >::changeVariableLabel(NodeId id,
226  const std::string& old_label,
227  const std::string& new_label) {
228  if (variable(id).varType() != VarType::Labelized) {
229  GUM_ERROR(NotFound, "Variable " << id << " is not a LabelizedVariable.");
230  }
231  LabelizedVariable* var = dynamic_cast< LabelizedVariable* >(
232  const_cast< DiscreteVariable* >(&variable(id)));
233 
234  var->changeLabel(var->posLabel(old_label), new_label);
235  }
236 
237  template < typename GUM_SCALAR >
238  INLINE NodeId
239  MarkovNet< GUM_SCALAR >::nodeId(const DiscreteVariable& var) const {
240  return varMap__.get(var);
241  }
242 
243  template < typename GUM_SCALAR >
244  const Potential< GUM_SCALAR >&
245  MarkovNet< GUM_SCALAR >::factor(const NodeSet& varIds) const {
246  return *factors__[varIds];
247  }
248 
249  template < typename GUM_SCALAR >
250  const NodeSet&
251  MarkovNet< GUM_SCALAR >::smallestFactorFromNode(NodeId node) const {
252  const NodeSet* res = nullptr;
253  Size smallest = size();
254  for (const auto& kv: factors()) {
255  const auto& fact = kv.first;
256  if (fact.contains(node))
257  if (smallest > fact.size()) {
258  res = &fact;
259  smallest = fact.size();
260  }
261  }
262  if (res == nullptr) {
263  GUM_ERROR(NotFound, "No factor containing node " << node)
264  } else {
265  return *res;
266  }
267  }
268 
269  template < typename GUM_SCALAR >
270  const Potential< GUM_SCALAR >& MarkovNet< GUM_SCALAR >::factor(
271  const std::vector< std::string >& varnames) const {
272  return factor(this->nodeset(varnames));
273  }
274 
275  template < typename GUM_SCALAR >
276  const FactorTable< GUM_SCALAR >& MarkovNet< GUM_SCALAR >::factors() const {
277  return factors__;
278  }
279 
280  template < typename GUM_SCALAR >
281  INLINE NodeId MarkovNet< GUM_SCALAR >::add(const std::string& name,
282  unsigned int nbrmod) {
283  if (nbrmod < 2) {
284  GUM_ERROR(OperationNotAllowed,
285  "Variable " << name << "needs more than " << nbrmod
286  << " modalities");
287  }
288 
289  RangeVariable v(name, name, 0, nbrmod - 1);
290  return add(v);
291  }
292 
293  template < typename GUM_SCALAR >
294  INLINE void MarkovNet< GUM_SCALAR >::rebuildGraph__() {
295  if (topologyTransformationInProgress__) return;
296 
297  this->graph_.clearEdges();
298 
299  for (const auto& kv: factors__) {
300  const Potential< double >& c = *kv.second;
301  for (Idx i = 0; i < c.nbrDim(); i++)
302  for (Idx j = i + 1; j < c.nbrDim(); j++)
303  this->graph_.addEdge(varMap__.get(c.variable(i)),
304  varMap__.get(c.variable(j)));
305  }
306  }
307 
308 
309  template < typename GUM_SCALAR >
310  INLINE NodeId MarkovNet< GUM_SCALAR >::add(const DiscreteVariable& var) {
311  return add(var, graph().nextNodeId());
312  }
313 
314  template < typename GUM_SCALAR >
315  INLINE NodeId MarkovNet< GUM_SCALAR >::add(const DiscreteVariable& var,
316  NodeId id) {
317  varMap__.insert(id, var);
318  this->graph_.addNodeWithId(id);
319  return id;
320  }
321 
322  template < typename GUM_SCALAR >
323  INLINE NodeId
324  MarkovNet< GUM_SCALAR >::idFromName(const std::string& name) const {
325  return varMap__.idFromName(name);
326  }
327 
328  template < typename GUM_SCALAR >
329  INLINE const DiscreteVariable&
330  MarkovNet< GUM_SCALAR >::variableFromName(const std::string& name) const {
331  return varMap__.variableFromName(name);
332  }
333 
334  template < typename GUM_SCALAR >
335  INLINE const VariableNodeMap& MarkovNet< GUM_SCALAR >::variableNodeMap() const {
336  return varMap__;
337  }
338 
339  template < typename GUM_SCALAR >
340  INLINE void MarkovNet< GUM_SCALAR >::erase(const DiscreteVariable& var) {
341  erase(varMap__.get(var));
342  }
343 
344  template < typename GUM_SCALAR >
345  INLINE void MarkovNet< GUM_SCALAR >::erase(const std::string& name) {
346  erase(idFromName(name));
347  }
348 
349  template < typename GUM_SCALAR >
350  void MarkovNet< GUM_SCALAR >::erase(NodeId varId) {
351  if (!varMap__.exists(varId)) {
352  GUM_ERROR(InvalidArgument, "No node with id " << varId << ".")
353  }
354  varMap__.erase(varId);
355  this->graph_.eraseNode(varId);
356 
357  std::vector< NodeSet > vs;
358  for (const auto& kv: factors__) {
359  if (kv.first.contains(varId)) { vs.push_back(kv.first); }
360  }
361  for (const auto& ns: vs) {
362  eraseFactor__(ns);
363  }
364  for (const auto& ns: vs) {
365  NodeSet nv = ns;
366  nv.erase(varId);
367  if (nv.size() > 1) addFactor__(nv);
368  }
369  rebuildGraph__();
370  }
371 
372  template < typename GUM_SCALAR >
373  void MarkovNet< GUM_SCALAR >::clear() {
374  if (!this->empty()) {
375  auto l = this->nodes();
376  for (const auto no: l) {
377  this->erase(no);
378  }
379  }
380  rebuildGraph__();
381  }
382 
383 
384  template < typename GUM_SCALAR >
385  INLINE std::ostream& operator<<(std::ostream& output,
386  const MarkovNet< GUM_SCALAR >& mn) {
387  output << mn.toString();
388  return output;
389  }
390 
391  template < typename GUM_SCALAR >
392  INLINE const Potential< GUM_SCALAR >&
393  MarkovNet< GUM_SCALAR >::addFactor(const NodeSet& vars) {
394  if (vars.size() == 0) {
395  GUM_ERROR(InvalidArgument, "Empty factor cannot be added.")
396  }
397 
398  if (factors__.exists(vars)) {
399  GUM_ERROR(InvalidArgument, "A factor for (" << vars << ") already exists.")
400  }
401 
402  auto res = addFactor__(vars);
403  rebuildGraph__();
404 
405  return *res;
406  }
407 
408  template < typename GUM_SCALAR >
409  INLINE const Potential< GUM_SCALAR >& MarkovNet< GUM_SCALAR >::addFactor(
410  const std::vector< std::string >& varnames) {
411  auto vars = this->nodeset(varnames);
412  if (factors__.exists(vars)) {
413  GUM_ERROR(InvalidArgument,
414  "A factor for (" << varnames << ") already exists.")
415  }
416 
417  return addFactor(vars);
418  }
419 
420  template < typename GUM_SCALAR >
421  INLINE const Potential< GUM_SCALAR >&
422  MarkovNet< GUM_SCALAR >::addFactor(const Potential< GUM_SCALAR >& factor) {
423  if (factor.nbrDim() == 0) {
424  GUM_ERROR(InvalidArgument, "Empty factor cannot be added.");
425  }
426 
427  NodeSet key;
428  for (Idx i = 0; i < factor.nbrDim(); i++) {
429  key.insert(idFromName(factor.variable(i).name()));
430  }
431 
432  if (factors__.exists(key)) {
433  GUM_ERROR(InvalidArgument, "A factor for (" << key << ") already exists.");
434  }
435 
436  auto res = addFactor__(key, &factor);
437  rebuildGraph__();
438 
439  return *res;
440  }
441 
442  template < typename GUM_SCALAR >
443  INLINE const Potential< GUM_SCALAR >*
444  MarkovNet< GUM_SCALAR >::addFactor__(const NodeSet& vars,
445  const Potential< GUM_SCALAR >* src) {
446  Potential< GUM_SCALAR >* factor = new Potential< GUM_SCALAR >();
447 
448  // in order to be deterministic, the Potential contains all the vars, sorted by
449  // id.
450  std::vector< NodeId > sorted_nodes;
451  for (auto node: vars) {
452  sorted_nodes.push_back(node);
453  }
454  std::sort(sorted_nodes.begin(), sorted_nodes.end());
455  for (auto node: sorted_nodes) {
456  factor->add(variable(node));
457  }
458 
459  if (src != nullptr) { factor->fillWith(*src); }
460  factors__.insert(vars, factor);
461 
462  return factor;
463  }
464 
465 
466  template < typename GUM_SCALAR >
467  INLINE void MarkovNet< GUM_SCALAR >::generateFactors() const {
468  for (const auto& elt: factors__) {
469  elt.second->random();
470  }
471  }
472 
473  template < typename GUM_SCALAR >
474  INLINE void MarkovNet< GUM_SCALAR >::generateFactor(const NodeSet& vars) const {
475  factors__[vars]->random();
476  }
477 
478  template < typename GUM_SCALAR >
479  INLINE void MarkovNet< GUM_SCALAR >::eraseFactor(const NodeSet& vars) {
480  if (factors__.exists(vars)) {
481  eraseFactor__(vars);
482  rebuildGraph__();
483  } else {
484  GUM_ERROR(InvalidArgument, "No factor for " << vars << ".")
485  }
486  }
487 
488  template < typename GUM_SCALAR >
489  INLINE void MarkovNet< GUM_SCALAR >::eraseFactor(
490  const std::vector< std::string >& varnames) {
491  auto vars = this->nodeset(varnames);
492  if (factors__.exists(vars)) {
493  eraseFactor__(vars);
494  rebuildGraph__();
495  } else {
496  GUM_ERROR(InvalidArgument, "No factor for " << varnames << ".")
497  }
498  }
499 
500  template < typename GUM_SCALAR >
501  INLINE void MarkovNet< GUM_SCALAR >::eraseFactor__(const NodeSet& vars) {
502  delete factors__[vars];
503  factors__.erase(vars);
504  }
505 
506  template < typename GUM_SCALAR >
507  void MarkovNet< GUM_SCALAR >::clearFactors__() {
508  for (const auto& kv: factors__) {
509  delete kv.second;
510  }
511  factors__.clear();
512  rebuildGraph__();
513  }
514 
515  template < typename GUM_SCALAR >
516  void MarkovNet< GUM_SCALAR >::copyFactors__(
517  const MarkovNet< GUM_SCALAR >& source) {
518  clearFactors__();
519  for (const auto& pf: source.factors()) {
520  addFactor__(pf.first, pf.second);
521  }
522  rebuildGraph__();
523  }
524 
525  template < typename GUM_SCALAR >
526  INLINE void MarkovNet< GUM_SCALAR >::beginTopologyTransformation() {
527  topologyTransformationInProgress__ = true;
528  }
529 
530  template < typename GUM_SCALAR >
531  INLINE void MarkovNet< GUM_SCALAR >::endTopologyTransformation() {
532  if (topologyTransformationInProgress__) {
533  topologyTransformationInProgress__
534  = false; // before rebuildGraph of course
535  rebuildGraph__();
536  }
537  }
538 } /* namespace gum */
gum::Set::emplace
INLINE void emplace(Args &&... args)
Definition: set_tpl.h:669
gum::build_node_for_MN
NodeId build_node_for_MN(MarkovNet< GUM_SCALAR > &mn, std::string node, Size default_domain_size)
Definition: MarkovNet_tpl.h:59
aGrUM 0.20.2
Sun May 2 2021 12:35:50
© PHW&CG&others - 2021
DoXyGeN 1.8.13