pyAgrum-nightly 2.3.1.9.dev202512261765915415__cp310-abi3-macosx_10_15_x86_64.whl

pyagrum/explain/_ShapCausalValues.py

@@ -0,0 +1,208 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+import pyagrum as gum
+from pyagrum.explain._ShapleyValues import ShapleyValues
+from pyagrum.explain._ComputationCausal import CausalComputation
+from pyagrum.explain._CustomShapleyCache import CustomShapleyCache
+from pyagrum.explain._FIFOCache import FIFOCache
+
+# Calculus
+import numpy as np
+import pandas as pd
+
+# GL
+import warnings
+
+
+class CausalShapValues(ShapleyValues, CausalComputation):
+  """
+  The CausalShapValues class computes the Causal Shapley values for a given target node in a Bayesian Network.
+  """
+
+  def __init__(self, bn, target, background: tuple | None, sample_size=1000, logit=True):
+    """
+    Parameters:
+    ------
+    bn : pyagrum.BayesNet
+        The Bayesian Network.
+    target : int | str
+        The node id (or node name) of the target.
+    background : Tuple(pandas.DataFrame, bool) | None
+        A tuple containing a pandas DataFrame and a boolean indicating whether the DataFrame contains labels or positions.
+    sample_size : int
+        The size of the background sample to generate if `background` is None.
+    logit : bool
+        If True, applies the logit transformation to the probabilities.
+
+    Raises:
+    ------
+    TypeError : If bn is not a gum.BayesNet instance, background is not a tuple or target is not an integer or string.
+    ValueError : If target is not a valid node id in the Bayesian Network or if sample_size is not a positive integer.
+    """
+    super().__init__(bn, target, logit)
+    # Processing background data
+    if background is None:
+      if not isinstance(sample_size, int):
+        raise TypeError("When `data`=None, `sample_size` must be an integer, but got {}".format(type(sample_size)))
+      else:
+        if sample_size <= 1:
+          raise ValueError("`sample_size` must be greater than 1, but got {}".format(sample_size))
+      data = gum.generateSample(self.bn, sample_size, with_labels=False)[0].reindex(columns=self.feat_names).to_numpy()
+    else:
+      if not isinstance(background, tuple):
+        raise TypeError(f"`background` must be a tuple (pd.DataFrame, bool).")
+      data, with_labels = background
+      if not isinstance(with_labels, bool):
+        warnings.warn(
+          f"The second element of `background` should be a boolean, but got {type(with_labels)}. Unexpected calculations may occur."
+        )
+      if not isinstance(data, pd.DataFrame):
+        raise TypeError("The first element of `background` must be a pandas DataFrame, but got {}".format(type(data)))
+      if data.shape[0] < 2:
+        warnings.warn("You are giving a single row as a background data, which will lead to biased Shapley values.")
+      if data.shape[1] != self.M:
+        raise ValueError(
+          "The number of columns in the background data must match the number of variables in the Bayesian network. Although values outside the Markov blanket, including the target, are unused, they are required for indexing purposes."
+        )
+      data = data.reindex(columns=self.feat_names).to_numpy()
+      if with_labels:
+        data = self._labelToPos_df(data, [i for i in range(self.M) if i != self.target])
+    self._data, self.counts = np.unique(data, return_counts=True, axis=0)
+    self._N = len(self._data)
+    # Calculating the baseline
+    self.baseline = self.func(
+      self._value(
+        data=self._data,
+        counts=self.counts,
+        elements=[i for i in range(self.M) if i != self.target],
+        sigma=self._mb,
+        cache=FIFOCache(100),
+        func1=self._posterior,
+        params1={},
+        func2=self._weight,
+        params2={"doLazy": gum.LazyPropagation(self.bn)},
+      )
+    )
+
+  def _shap_1dim(self, x, elements):
+    # Computes the Shapley values for a 1-dimensional input x (local explanation).
+    contributions = np.zeros((self.M, self.bn.variable(self.target).domainSize()))  # Initializes contributions array.
+    cache = CustomShapleyCache(5000)
+    markovImpact = FIFOCache(1000)
+    cache.set(0, (), self.baseline)  # Sets the baseline probability in the cache.
+    coalitions = self._coalitions(elements)  # Compute the coalitions
+
+    for tau in coalitions:
+      self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+      doNet = self._doCalculus(self.bn, tau)  # Creates a new Bayesian Network to perform do-calculus.
+      sigma = self._outOfCoalition(tau, range(self.M))  # Extracts the nodes outside the coalition tau.
+      alpha = x[tau]  # Instanciation of tau
+      self._chgCpt(doNet, tau, alpha)  # Changes the conditional probability tables to perform do-calculus.
+      doLazy = gum.LazyPropagation(
+        doNet
+      )  # Creates a lazy propagation inference engine to compute partial join probabilities.
+      doLazy.addTarget(self.target)
+      idx = self._extract(self._data, tau, alpha)
+      posterior_with = self.func(
+        self._value(
+          data=self._data[idx],
+          counts=self.counts[idx],
+          elements=elements,
+          sigma=sigma,
+          cache=markovImpact,
+          func1=self._posterior,
+          params1={},
+          func2=self._weight,
+          params2={"doLazy": doLazy},
+        )
+      )
+
+      cache.set(0, tuple(tau), posterior_with)
+      # Contribution of each feature
+      for t in tau:
+        key = tuple((f for f in tau if f != t))
+        posterior_without = cache.get(0, key)
+        contributions[t] += self._shap_term(posterior_with, posterior_without, len(elements), len(tau) - 1)
+    return contributions
+
+  def _shap_ndim(self, x, elements):
+    contributions = np.zeros(
+      (self.M, len(x), self.bn.variable(self.target).domainSize())
+    )  # Initializes contributions array.
+    cache = CustomShapleyCache(5000)  # Initializes the custom cache.
+    markovImpact = FIFOCache(1000)
+    cache.set(0, (), self.baseline)  # Sets the baseline probability in the cache.
+    coalitions = self._coalitions(elements)  # Compute the coalitions
+
+    for tau in coalitions:
+      self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+      doNet = self._doCalculus(self.bn, tau)  # Creates a new Bayesian Network to perform do-calculus.
+      sigma = self._outOfCoalition(tau, range(self.M))  # Extracts the nodes outside the coalition tau.
+
+      for i in range(len(x)):  # Iterates over each example in x
+        alpha = x[i, tau]  # Instanciation of tau
+        self._chgCpt(doNet, tau, alpha)  # Changes the conditional probability tables to perform do-calculus.
+        doLazy = gum.LazyPropagation(
+          doNet
+        )  # Creates a lazy propagation inference engine to compute partial join probabilities.
+        doLazy.addTarget(self.target)
+        idx = self._extract(self._data, tau, alpha)
+        posterior_with = self.func(
+          self._value(
+            data=self._data[idx],
+            counts=self.counts[idx],
+            elements=elements,
+            sigma=sigma,
+            cache=markovImpact,
+            func1=self._posterior,
+            params1={},
+            func2=self._weight,
+            params2={"doLazy": doLazy},
+          )
+        )
+
+        cache.set(i, tuple(tau), posterior_with)
+        # Contribution of each feature
+        for t in tau:
+          key = tuple((f for f in tau if f != t))
+          posterior_without = cache.get(i, key) if len(key) > 0 else cache.get(0, ())
+          contributions[t, i] += self._shap_term(posterior_with, posterior_without, len(elements), len(tau) - 1)
+    return contributions

pyagrum/explain/_ShapConditionalValues.py

@@ -0,0 +1,126 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+from pyagrum.explain._ShapleyValues import ShapleyValues
+from pyagrum.explain._CustomShapleyCache import CustomShapleyCache
+
+# Calculations
+import numpy as np
+
+
+class ConditionalShapValues(ShapleyValues):
+  """
+  The ConditionalShapValues class computes the conditional Shapley values for a given target node in a Bayesian Network.
+  """
+
+  def __init__(self, bn, target, logit=True):
+    """
+    Parameters:
+    ------
+    bn : pyagrum.BayesNet
+        The Bayesian Network.
+    target : int | str
+        The node id (or node name) of the target.
+    logit : bool
+        If True, applies the logit transformation to the probabilities.
+
+    Raises:
+    ------
+    TypeError : If bn is not a gum.BayesNet or target is not an integer or string.
+    ValueError : If target is not a valid node id in the Bayesian Network.
+    """
+    super().__init__(bn, target, logit)  # Initializes the ShapleyValues class.
+    self.baseline = self.func(self.ie.posterior(self.target).toarray())  # Sets the baseline probability.
+
+  def _coalition_contribution(self, k, ex, _M, feature, nodes_id, nodes_vals, cache):
+    key1, key2, key_m = cache.generate_keys(self.bn, self.target, feature, nodes_id)
+    if k == 0:
+      self.ie.eraseAllEvidence()
+      if len(key1) == len(key_m):
+        # If all nodes impact the target.
+        # In this case, we are obliged to calculate the posterior probability.
+        evidces = {key: int(value) for key, value in zip(nodes_id, nodes_vals)}
+        self.ie.updateEvidence(evidces)  # Updates the evidence in the inference engine.
+        cache.set(
+          ex, key1, self.func(self.ie.posterior(self.target).toarray())
+        )  # Sets the posterior probability in the cache.
+      else:
+        # Otherwise, we have already calculated the posterior probability.
+        if len(key1) > 1:
+          cache.set(ex, key1, cache.get(ex, key_m))
+        else:
+          cache.set(ex, key1, cache.get(-1, ""))
+    posterior_prob_with = cache.get(ex, key1)
+    posterior_prob_without = cache.get(ex, key2) if len(key1) > 1 else cache.get(-1, "")
+    return self._shap_term(posterior_prob_with, posterior_prob_without, _M, len(nodes_id) - 1)
+
+  def _shap_1dim(self, x, elements) -> np.ndarray:
+    contributions = np.zeros((self.M, self.bn.variable(self.target).domainSize()))  # Initializes contributions array.
+    self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+    cache = CustomShapleyCache(5000)  # Initializes the custom cache.
+    cache.set(-1, "", self.baseline)  # Sets the baseline probability in the cache.
+
+    coalitions = self._coalitions(elements)  # Generates coalitions.
+    for nodes_id in coalitions:
+      nodes_vals = x[nodes_id]  # Gets the values of the nodes in the coalition.
+      for k, feature in enumerate(nodes_id):
+        # Accumulates the contribution for each feature.
+        contributions[feature] += self._coalition_contribution(
+          k, 0, len(elements), int(feature), nodes_id, nodes_vals, cache
+        )
+    return contributions
+
+  def _shap_ndim(self, x, elements) -> np.ndarray:
+    contributions = np.zeros(
+      (self.M, len(x), self.bn.variable(self.target).domainSize())
+    )  # Initializes contributions array.
+    self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+    cache = CustomShapleyCache(5000)  # Initializes the custom cache.
+    cache.set(-1, "", self.baseline)  # Sets the baseline probability in the cache.
+
+    coalitions = self._coalitions(elements)  # Generates coalitions.
+    for nodes_id in coalitions:
+      data_vals = x[:, nodes_id]  # Gets the values of the nodes in the coalition.
+      for ex, nodes_vals in enumerate(data_vals):
+        for k, feature in enumerate(nodes_id):
+          contributions[feature, ex] += self._coalition_contribution(
+            k, ex, len(elements), int(feature), nodes_id, nodes_vals, cache
+          )
+    return contributions

pyagrum/explain/_ShapMarginalValues.py

@@ -0,0 +1,191 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+from pyagrum.explain._ShapleyValues import ShapleyValues
+from pyagrum.explain._ComputationMarginal import MarginalComputation
+from pyagrum.explain._CustomShapleyCache import CustomShapleyCache
+from pyagrum.explain._FIFOCache import FIFOCache
+
+# Calculations
+import pandas as pd
+import numpy as np
+
+# aGrUM
+import pyagrum as gum
+
+# GL
+import warnings
+
+
+class MarginalShapValues(ShapleyValues, MarginalComputation):
+  """
+  The MarginalShapValues class computes the Marginal Shapley values for a given target node in a Bayesian Network.
+  """
+
+  def __init__(self, bn: gum.BayesNet, target: int, background: tuple | None, sample_size=1000, logit=True):
+    """
+    Parameters:
+    ------
+    bn : pyagrum.BayesNet
+        The Bayesian Network.
+    target : int | str
+        The node id (or node name) of the target.
+    background : Tuple(pandas.DataFrame, bool) | None
+        A tuple containing a pandas DataFrame and a boolean indicating whether the DataFrame contains labels or positions.
+    sample_size : int
+        The size of the background sample to generate if `background` is None.
+    logit : bool
+        If True, applies the logit transformation to the probabilities.
+
+    Raises:
+    ------
+    TypeError : If bn is not a gum.BayesNet instance, background is not a tuple or target is not an integer or string.
+    ValueError : If target is not a valid node id in the Bayesian Network or if sample_size is not a positive integer.
+    """
+    super().__init__(bn, target, logit)
+    self._mb = self._markov_blanket()
+    # Processing background data
+    if background is None:
+      if not isinstance(sample_size, int):
+        raise TypeError("When `data`=None, `sample_size` must be an integer, but got {}".format(type(sample_size)))
+      else:
+        if sample_size < 1:
+          raise ValueError("`sample_size` must be greater than 1, but got {}".format(sample_size))
+        elif sample_size < 10:
+          warnings.warn("The sample size is small, which may lead to biased Shapley values.")
+      data = gum.generateSample(self.bn, sample_size, with_labels=False)[0].reindex(columns=self.feat_names).to_numpy()
+    else:
+      if not isinstance(background, tuple):
+        raise TypeError(f"`background` must be a tuple (pd.DataFrame, bool).")
+      data, with_labels = background
+      if not isinstance(with_labels, bool):
+        warnings.warn(
+          f"The second element of `background` should be a boolean, but got {type(with_labels)}. Unexpected calculations may occur."
+        )
+      if not isinstance(data, pd.DataFrame):
+        raise TypeError("The first element of `background` must be a pandas DataFrame, but got {}".format(type(data)))
+      if data.shape[0] < 2:
+        warnings.warn("You are giving a single row as a background data, which will lead to biased Shapley values.")
+      if data.shape[1] != self.M:
+        raise ValueError(
+          "The number of columns in the background data must match the number of variables in the Bayesian network. Although values outside the Markov blanket, including the target, are unused, they are required for indexing purposes."
+        )
+      data = data.reindex(columns=self.feat_names).to_numpy()
+      if with_labels:
+        data = self._labelToPos_df(data, [i for i in range(self.M) if i != self.target])
+    self._data, self.counts = np.unique(data, axis=0, return_counts=True)
+    self._N = int(np.sum(self.counts))
+    if self._N == 0:
+      raise ValueError("Background data can't be empty.")
+    self.baseline = self.func(
+      self._value(
+        data=self._data,
+        counts=self.counts,
+        elements=[i for i in range(self.M) if i != self.target],
+        sigma=[],
+        cache=FIFOCache(100),
+        func1=self._posterior,
+        params1={},
+        func2=self._weight,
+        params2={},
+      )
+    )
+
+  def _coalition_contribution(self, k, ex, elements, feature, markovImpact, nodes_id, nodes_vals, cache):
+    # Computes the contribution of a coalition to the Shapley value.
+    key1, key2, _ = cache.generate_keys(self.bn, self.target, feature, nodes_id)
+    if k == 0:
+      interv = self._data.copy()
+      interv[:, nodes_id] = nodes_vals
+      cache.set(
+        ex,
+        key1,
+        self.func(
+          self._value(
+            data=interv,
+            counts=self.counts,
+            elements=elements,
+            sigma=[],
+            cache=markovImpact,
+            func1=self._posterior,
+            params1={},
+            func2=self._weight,
+            params2={},
+          )
+        ),
+      )
+
+    posterior_prob_with = cache.get(ex, key1)
+    posterior_prob_without = cache.get(ex, key2) if len(key1) > 1 else cache.get(-1, ())
+    return self._shap_term(posterior_prob_with, posterior_prob_without, len(elements), len(nodes_id) - 1)
+
+  def _shap_1dim(self, x, elements):
+    contributions = np.zeros((self.M, self.bn.variable(self.target).domainSize()))  # Initializes contributions array.
+    self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+    markovImpact = FIFOCache(2000)
+    cache = CustomShapleyCache(5000)  # Initializes the custom cache.
+    cache.set(-1, (), self.baseline)  # Sets the baseline probability in the cache.
+    coalitions = self._coalitions(elements)
+    for nodes_id in coalitions:
+      nodes_vals = x[nodes_id]  # Gets the values of the nodes in the coalition.
+      for k, feature in enumerate(nodes_id):
+        # Accumulates the contribution for each feature.
+        contributions[feature] += self._coalition_contribution(
+          k, 0, elements, int(feature), markovImpact, nodes_id, nodes_vals, cache
+        )
+    return contributions
+
+  def _shap_ndim(self, x, elements):
+    # Result initialisation.
+    contributions = np.zeros(
+      (self.M, len(x), self.bn.variable(self.target).domainSize())
+    )  # Initializes contributions array.
+    self.ie.eraseAllEvidence()  # Clears all evidence from the inference engine.
+    markovImpact = FIFOCache(2000)
+    cache = CustomShapleyCache(5000)  # Initializes the custom cache.
+    cache.set(-1, (), self.baseline)  # Sets the baseline probability in the cache.
+    coalitions = self._coalitions(elements)  # Generates coalitions.
+    for nodes_id in coalitions:
+      for ex, nodes_values in enumerate(x[:, nodes_id]):
+        for k, feature in enumerate(nodes_id):
+          contributions[feature, ex] += self._coalition_contribution(
+            k, ex, elements, int(feature), markovImpact, nodes_id, nodes_values, cache
+          )
+    return contributions