aGrUM 3.1.1
a C++ library for (probabilistic) graphical models
informationTheory_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
49#include <utility>
50
51#include <agrum/base/core/exceptions.h>
52#include <agrum/base/graphicalModels/algorithms/informationTheory.h>
53#include <agrum/BN/inference/lazyPropagation.h>
54
55#include <agrum/base/core/math/math_utils.h>
56
57#define INFORMATION_THEORY_TEMPLATE \
58 template < template < typename > class INFERENCE_ENGINE, \
59 typename GUM_SCALAR > //@todo when CLANG-compliant for virtual class : requires
60 // JointTargettable< INFERENCE_ENGINE< GUM_SCALAR > >
61
62namespace gum {
63 INFORMATION_THEORY_TEMPLATE
64 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory(
65 INFERENCE_ENGINE< GUM_SCALAR >& engine,
66 gum::NodeSet X,
67 gum::NodeSet Y,
68 gum::NodeSet Z) : engine_(engine), X_(std::move(X)), Y_(std::move(Y)), Z_(std::move(Z)) {
69 GUM_CONSTRUCTOR(InformationTheory)
70 if ((!(X_ * Y_).empty()) || (!(X_ * Z_).empty()) || (!(Z_ * Y_).empty()))
71 GUM_ERROR(OperationNotAllowed, "The intersection between the set of variables must be empty")
72 makeInference_();
73 }
74
75 INFORMATION_THEORY_TEMPLATE
76 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory(
77 INFERENCE_ENGINE< GUM_SCALAR >& engine,
78 const gum::NodeSet& X,
79 const gum::NodeSet& Y) : InformationTheory(engine, X, Y, NodeSet()) {}
80
81 INFORMATION_THEORY_TEMPLATE
82 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory(
83 INFERENCE_ENGINE< GUM_SCALAR >& engine,
84 const std::vector< std::string >& Xnames,
85 const std::vector< std::string >& Ynames) :
86 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >(engine,
87 engine.model().nodeset(Xnames),
88 engine.model().nodeset(Ynames),
89 NodeSet()) {}
90
91 INFORMATION_THEORY_TEMPLATE
92 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory(
93 INFERENCE_ENGINE< GUM_SCALAR >& engine,
94 const std::vector< std::string >& Xnames,
95 const std::vector< std::string >& Ynames,
96 const std::vector< std::string >& Znames) :
97 InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >(engine,
98 engine.model().nodeset(Xnames),
99 engine.model().nodeset(Ynames),
100 engine.model().nodeset(Znames)) {}
101
102 INFORMATION_THEORY_TEMPLATE
106
107 INFORMATION_THEORY_TEMPLATE
108 void InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::makeInference_() {
109 vX_.clear();
110 for (const auto x: X_)
111 vX_.insert(&engine_.model().variable(x));
112
113 vY_.clear();
114 for (const auto y: Y_)
115 vY_.insert(&engine_.model().variable(y));
116
117 vZ_.clear();
118 for (const auto z: Z_)
119 vZ_.insert(&engine_.model().variable(z));
120
121 const NodeSet joint_vars = X_ + Y_ + Z_;
122 if (!engine_.isJointTarget(joint_vars)) {
123 // we check if it is not an implicit target : containng a node and some of its parent (could
124 // be better)
125 bool implicit_target = false;
126 for (const auto node: joint_vars)
127 if (engine_.model().family(node).isSupersetOrEqual(joint_vars)) {
128 implicit_target = true;
129 break;
130 }
131 if (!implicit_target) {
132 engine_.eraseAllJointTargets();
133 engine_.addJointTarget(joint_vars);
134 }
135 }
136 engine_.makeInference();
137
138 if (!Z_.empty()) {
139 pXYZ_ = engine_.jointPosterior(joint_vars);
140 pXZ_ = pXYZ_.sumIn(vX_ + vZ_);
141 pYZ_ = pXYZ_.sumIn(vY_ + vZ_);
142 pZ_ = pXZ_.sumIn(vZ_);
143 pXY_ = pXYZ_.sumIn(vX_ + vY_);
144 } else {
145 pXY_ = engine_.jointPosterior(joint_vars);
146 }
147 pX_ = pXY_.sumIn(vX_);
148 pY_ = pXY_.sumIn(vY_);
149 }
150
151 INFORMATION_THEORY_TEMPLATE
152 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyX() { return pX_.entropy(); }
153
154 INFORMATION_THEORY_TEMPLATE
155 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyY() { return pY_.entropy(); }
156
157 INFORMATION_THEORY_TEMPLATE
158 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXY() {
159 return pXY_.entropy();
160 }
161
162 INFORMATION_THEORY_TEMPLATE
163 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenY() {
164 return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
165 // f(x,y)=log (p(x,y)/p(y))
166 const auto& pxy = pXY_[i];
167 if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
168
169 const auto& py = pY_[i];
170 if (py == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
171
172 return GUM_LOG2_OR_0(pxy / py);
173 });
174 }
175
176 INFORMATION_THEORY_TEMPLATE
177 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyYgivenX() {
178 return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
179 // f(x,y)=log (p(x,y)/p(x))
180 const auto& pxy = pXY_[i];
181 if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
182
183 const auto& px = pX_[i];
184 if (px == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
185
186 return GUM_LOG2_OR_0(pxy / px);
187 });
188 }
189
190 INFORMATION_THEORY_TEMPLATE
191 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenZ() {
192 if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
193 return -pXZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
194 // f(x,z)=log (p(x,z)/p(z))
195 const auto& pxz = pXZ_[i];
196 if (pxz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
197
198 const auto& pz = pZ_[i];
199 if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
200
201 return GUM_LOG2_OR_0(pxz / pz);
202 });
203 }
204
205 INFORMATION_THEORY_TEMPLATE
206 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyYgivenZ() {
207 if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
208 return -pYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
209 // f(y,z)=log (p(y,z)/p(z))
210 const auto& pyz = pYZ_[i];
211 if (pyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
212
213 const auto& pz = pZ_[i];
214 if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
215
216 return GUM_LOG2_OR_0(pyz / pz);
217 });
218 }
219
220 INFORMATION_THEORY_TEMPLATE
221 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::mutualInformationXY() {
222 return pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
223 // f(x,y)=log (p(x,y)/p(x)p(y))
224 const auto& pxy = pXY_[i];
225 if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
226
227 const auto& pxpy = pY_[i] * pX_[i];
228 if (pxpy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
229
230 return GUM_LOG2_OR_0(pxy / pxpy);
231 });
232 }
233
234 INFORMATION_THEORY_TEMPLATE
235 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::variationOfInformationXY() {
236 return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
237 // f(x,y)= -log(p(x)*p(y))
238 return GUM_LOG2_OR_0(pY_[i] * pX_[i]);
239 });
240 }
241
242 INFORMATION_THEORY_TEMPLATE
243 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXYgivenZ() {
244 if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
245 return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
246 // f(x,y,z)= -log(p(x,y,z)/p(z))
247 const auto& pxyz = pXYZ_[i];
248 if (pxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
249
250 const auto& pz = pZ_[i];
251 if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
252
253 return -GUM_LOG2_OR_0(pxyz / pz);
254 });
255 }
256
257 INFORMATION_THEORY_TEMPLATE
258 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenYZ() {
259 if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
260 return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
261 // f(x,y,z)= -log(p(x,y,z)/p(y,z))
262 const auto& pxyz = pXYZ_[i];
263 if (pxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
264
265 const auto& pyz = pYZ_[i];
266 if (pyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
267
268 return -GUM_LOG2_OR_0(pxyz / pyz);
269 });
270 }
271
272 INFORMATION_THEORY_TEMPLATE
273 GUM_SCALAR InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::mutualInformationXYgivenZ() {
274 if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
275 return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
276 // f(x,y)=log (p(x,y)/p(x)p(y))
277 const auto& pzpxyz = pXYZ_[i] * pZ_[i];
278 if (pzpxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
279
280 const auto& pxzpyz = pXZ_[i] * pYZ_[i];
281 if (pxzpyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
282
283 return GUM_LOG2_OR_0(pzpxyz / pxzpyz);
284 });
285 }
286
287#undef INFORMATION_THEORY_TEMPLATE
288} // namespace gum
ArgumentError
Exception base for argument error.
gum::InformationTheory::pY_
Tensor< GUM_SCALAR > pY_
Definition informationTheory.h:131
gum::InformationTheory::pXYZ_
Tensor< GUM_SCALAR > pXYZ_
Definition informationTheory.h:126
gum::InformationTheory::pX_
Tensor< GUM_SCALAR > pX_
Definition informationTheory.h:130
gum::InformationTheory::InformationTheory
InformationTheory(INFERENCE_ENGINE< GUM_SCALAR > &engine, NodeSet X, NodeSet Y, NodeSet Z)
Definition informationTheory_tpl.h:64
gum::InformationTheory::pXZ_
Tensor< GUM_SCALAR > pXZ_
Definition informationTheory.h:128
gum::InformationTheory::pYZ_
Tensor< GUM_SCALAR > pYZ_
Definition informationTheory.h:129
gum::InformationTheory::pZ_
Tensor< GUM_SCALAR > pZ_
Definition informationTheory.h:132
gum::InformationTheory::engine_
INFERENCE_ENGINE< GUM_SCALAR > & engine_
Definition informationTheory.h:116
gum::InformationTheory::pXY_
Tensor< GUM_SCALAR > pXY_
Definition informationTheory.h:127
gum::Instantiation
Class for assigning/browsing values to tuples of discrete variables.
Definition instantiation.h:102
OperationNotAllowed
Exception : operation not allowed.
exceptions.h
aGrUM's exceptions
GUM_ERROR
#define GUM_ERROR(type, msg)
Definition exceptions.h:76
gum::NodeSet
Set< NodeId > NodeSet
Some typdefs and define for shortcuts ...
Definition graphElements.h:392
informationTheory.h
Class encapsulating computations of notions from Information Theory.
INFORMATION_THEORY_TEMPLATE
#define INFORMATION_THEORY_TEMPLATE
Definition informationTheory_tpl.h:57
lazyPropagation.h
Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networ...
math_utils.h
Useful macros for maths.
GUM_LOG2_OR_0
#define GUM_LOG2_OR_0(x)
Definition math_utils.h:70
gum
gum is the global namespace for all aGrUM entities
Definition agrum.h:46
std
STL namespace.
aGrUM 3.1.1

© PHW&CG&others - 2022
DoXyGeN 1.16.1