aGrUM 3.3.2
a C++ library for (probabilistic) graphical models
GibbsBNdistance_tpl.h
Go to the documentation of this file.
1/****************************************************************************
2 * This file is part of the aGrUM/pyAgrum library. *
3 * *
4 * Copyright (c) 2005-2026 by *
5 * - Pierre-Henri WUILLEMIN(_at_LIP6) *
6 * - Christophe GONZALES(_at_AMU) *
7 * *
8 * The aGrUM/pyAgrum library is free software; you can redistribute it *
9 * and/or modify it under the terms of either : *
10 * *
11 * - the GNU Lesser General Public License as published by *
12 * the Free Software Foundation, either version 3 of the License, *
13 * or (at your option) any later version, *
14 * - the MIT license (MIT), *
15 * - or both in dual license, as here. *
16 * *
17 * (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html) *
18 * *
19 * This aGrUM/pyAgrum library is distributed in the hope that it will be *
20 * useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
21 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
22 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE *
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, *
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR *
26 * OTHER DEALINGS IN THE SOFTWARE. *
27 * *
28 * See LICENCES for more details. *
29 * *
30 * SPDX-FileCopyrightText: Copyright 2005-2026 *
31 * - Pierre-Henri WUILLEMIN(_at_LIP6) *
32 * - Christophe GONZALES(_at_AMU) *
33 * SPDX-License-Identifier: LGPL-3.0-or-later OR MIT *
34 * *
35 * Contact : info_at_agrum_dot_org *
36 * homepage : http://agrum.gitlab.io *
37 * gitlab : https://gitlab.com/agrumery/agrum *
38 * *
39 ****************************************************************************/
40
41#pragma once
42
43
50
54#include <agrum/BN/IBayesNet.h>
56
58
59namespace gum {
60
61
62 template < GUM_Numeric GUM_SCALAR >
64 const IBayesNet< GUM_SCALAR >& Q) :
65 BNdistance< GUM_SCALAR >(P, Q), ApproximationScheme(),
66 GibbsOperator< GUM_SCALAR >(P, nullptr, "gibbsKL") {
67 GUM_CONSTRUCTOR(GibbsBNdistance);
68
69 setFromConfiguration_("gibbsKL", true);
70 }
71
72 template < GUM_Numeric GUM_SCALAR >
74 BNdistance< GUM_SCALAR >(kl), ApproximationScheme(),
75 GibbsOperator< GUM_SCALAR >(kl.p(), nullptr, "gibbsKL") {
76 GUM_CONSTRUCTOR(GibbsBNdistance);
77
78 setFromConfiguration_("gibbsKL", true);
79 }
80
81 template < GUM_Numeric GUM_SCALAR >
85
86 template < GUM_Numeric GUM_SCALAR >
88 auto Iq = q_.completeInstantiation();
91
92 // map between particle() variables and q_ variables (using name of vars)
94
95 for (Idx ite = 0; ite < I.nbrDim(); ++ite) {
96 map.insert(&I.variable(ite), &q_.variableFromName(I.variable(ite).name()));
97 }
98
99 // BURN IN
100 this->updateSamplingNodes_();
101 for (Idx i = 0; i < burnIn(); i++)
102 I = this->nextSample(I);
103
104 // SAMPLING
105 klPQ_ = klQP_ = hellinger_ = jsd_ = (GUM_SCALAR)0.0;
106 errorPQ_ = errorQP_ = 0;
108 GUM_SCALAR delta, ratio, error;
109 delta = ratio = error = (GUM_SCALAR)-1;
110 GUM_SCALAR oldPQ = 0.0;
111 GUM_SCALAR pp, pq, pmid;
112
113 do {
114 this->disableMinEpsilonRate();
115 I = this->nextSample(I);
117
118 //_p.synchroInstantiations( Ip,I);
119 Iq.setValsFrom(map, I);
120
121 pp = p_.jointProbability(I);
122 pq = q_.jointProbability(Iq);
123 pmid = (pp + pq) / 2.0;
124
125 if (pp != (GUM_SCALAR)0.0) {
126 hellinger_ += std::pow(std::sqrt(pp) - std::sqrt(pq), 2) / pp;
127
128 if (pq != (GUM_SCALAR)0.0) {
129 bhattacharya_ += std::sqrt(pq / pp); // std::sqrt(pp*pq)/pp
131 this->enableMinEpsilonRate(); // replace check_rate=true;
132 ratio = pq / pp;
133 delta = (GUM_SCALAR)std::log2(ratio);
134 klPQ_ += delta;
135
136 // pmid!=0
137 jsd_ -= std::log2(pp / pmid) + ratio * std::log2(pq / pmid);
138 } else {
139 errorPQ_++;
140 }
141 }
142
143 if (pq != (GUM_SCALAR)0.0) {
144 if (pp != (GUM_SCALAR)0.0) {
145 // if we are here, it is certain that delta and ratio have been
146 // computed
147 // further lines above. (for now #112-113)
148 klQP_ += (GUM_SCALAR)(-delta * ratio);
149 } else {
150 errorQP_++;
151 }
152 }
153
154 if (this->isEnabledMinEpsilonRate()) { // replace check_rate
155 // delta is used as a temporary variable
156 delta = klPQ_ / nbrIterations();
157 error = (GUM_SCALAR)std::abs(delta - oldPQ);
158 oldPQ = delta;
159 }
160 } while (continueApproximationScheme(error)); //
161
162 klPQ_ = -klPQ_ / (nbrIterations());
163 klQP_ = -klQP_ / (nbrIterations());
164 jsd_ = -0.5 * jsd_ / (nbrIterations());
165 hellinger_ = std::sqrt(hellinger_ / nbrIterations());
166 bhattacharya_ = -std::log(bhattacharya_ / (nbrIterations()));
167 }
168
169 template < GUM_Numeric GUM_SCALAR >
173
174 template < GUM_Numeric GUM_SCALAR >
176 return this->burn_in_;
177 }
178} // namespace gum
algorithm for approximated computation KL divergence between BNs using GIBBS sampling
Class representing the minimal interface for Bayesian network with no numerical data.
This file contains general scheme for iteratively convergent algorithms.
ApproximationScheme()
Build a scheme whose parameters are read from the configuration.
void updateApproximationScheme(unsigned int incr=1)
Update the scheme w.r.t the new error and increment steps.
void setFromConfiguration_(const std::string &section, bool withMaxTime, bool withVerbosity=true)
Set the parameters of the scheme from a section of gum::Configuration.
bool isEnabledMinEpsilonRate() const override
Returns true if stopping criterion on epsilon rate is enabled, false otherwise.
void disableMinEpsilonRate() override
Disable stopping criterion on epsilon rate.
bool continueApproximationScheme(double error)
Update the scheme w.r.t the new error.
void initApproximationScheme()
Initialise the scheme.
Size nbrIterations() const override
Returns the number of iterations.
void enableMinEpsilonRate() override
Enable stopping criterion on epsilon rate.
Size burn_in_
Number of iterations before checking stopping criteria.
GUM_SCALAR hellinger_
Definition BNdistance.h:165
GUM_SCALAR klPQ_
Definition BNdistance.h:159
BNdistance(const IBayesNet< GUM_SCALAR > &P, const IBayesNet< GUM_SCALAR > &Q)
constructor must give 2 BNs
GUM_SCALAR jsd_
Definition BNdistance.h:167
const IBayesNet< GUM_SCALAR > & p() const
GUM_SCALAR klQP_
Definition BNdistance.h:160
GUM_SCALAR bhattacharya_
Definition BNdistance.h:166
const IBayesNet< GUM_SCALAR > & q_
Definition BNdistance.h:157
const IBayesNet< GUM_SCALAR > & p_
Definition BNdistance.h:156
Size burnIn() const
Returns the number of burn in.
void setBurnIn(Size b)
Number of burn in for one iteration.
GibbsBNdistance(const IBayesNet< GUM_SCALAR > &P, const IBayesNet< GUM_SCALAR > &Q)
constructor must give 2 BNs
~GibbsBNdistance() override
destructor
Instantiation nextSample(Instantiation prev)
draws next sample of Gibbs sampling
Instantiation monteCarloSample()
draws a first sample with a positive probability (starting point of a Gibbs chain)
GibbsOperator(const IBayesNet< GUM_SCALAR > &BN, const NodeProperty< Idx > *hardEv, Size nbr=1, bool atRandom=false)
constructor
The class for generic Hash Tables.
Definition hashTable.h:640
value_type & insert(const Key &key, const Val &val)
Adds a new element (actually a copy of this element) into the hash table.
Class representing the minimal interface for Bayesian network with no numerical data.
Definition IBayesNet.h:79
Class for assigning/browsing values to tuples of discrete variables.
const DiscreteVariable & variable(Idx i) const final
Returns the variable at position i in the tuple.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
const std::string & name() const
returns the name of the variable
This file contains Gibbs sampling (for BNs) class definitions.
std::size_t Size
In aGrUM, hashed values are unsigned long int.
Definition types.h:74
Size Idx
Type for indexes.
Definition types.h:79
Class hash tables iterators.
Useful macros for maths.
gum is the global namespace for all aGrUM entities
Definition agrum.h:46