pyAgrum-nightly 2.3.0.9.dev202512061764412981__cp310-abi3-macosx_11_0_arm64.whl

pyagrum/ctbn/CTBNGenerator.py

@@ -0,0 +1,216 @@
+############################################################################
+#   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 typing import Tuple
+import pyagrum
+import random
+
+from pyagrum.ctbn import CIM
+from pyagrum.ctbn import CTBN
+from pyagrum.ctbn.constants import NodeId
+
+"""
+This file is used to generate random CTBNs using Prufer code
+"""
+
+
+def directTree(graph: pyagrum.MixedGraph, root: NodeId):
+  """
+  Direct a undirected tree.
+
+  Parameters
+  ----------
+  graph : pyagrum.MixedGraph
+      A graph that contains directed/undirected arcs.
+  root : NodeId
+      Root of the tree to direct.
+  """
+  for i in graph.neighbours(root):
+    graph.eraseEdge(i, root)
+    graph.addArc(root, i)
+    # CTBN.addArc(root, i)
+    directTree(graph, i)
+
+
+def randomCIMs(ctbn: CTBN, valueRange: Tuple[float, float]):
+  """
+  Fills the ``ctbn``'s CIMs with random values in ``valueRange``.
+  Note : as diagonal coefficents are the negative sum of the coefficients one the line,
+  their value does not necessarily belong to ``valueRange``.
+
+  Parameters
+  ----------
+  ctbn : CTBN
+      The ctbn to fill.
+  valueRange : Tuple[float, float]
+      Range to choose values from when filling the cims.
+  """
+
+  for v in ctbn.names():
+    v_i = ctbn.CIM(v).findVar(CIM.varI(v))
+    v_j = ctbn.CIM(v).findVar(CIM.varJ(v))
+
+    I1 = pyagrum.Instantiation(ctbn.CIM(v)._pot)
+    I2 = pyagrum.Instantiation()
+    ind = I1.pos(v_j)
+    I2.add(I1.variable(ind))
+
+    I1.setFirst()
+    while not I1.end():
+      I2.setFirst()
+      sumCIM = 0
+      while not I2.end():
+        I1.setVals(I2)
+        if I1.val(v_i) != I1.val(v_j):
+          draw = random.uniform(valueRange[0], valueRange[1])
+          sumCIM += draw
+          ctbn.CIM(v)._pot.set(I1, draw)
+        else:
+          ctbn.CIM(v)._pot.set(I1, 0)
+
+        I2.inc()
+
+      tmp = pyagrum.Instantiation(I1)
+      tmp.chgVal(v_j, tmp.val(v_i))
+      ctbn.CIM(v)._pot.set(tmp, -sumCIM)
+      I1.incOut(I2)
+
+
+def randomCTBN(valueRange: Tuple[float, float], n: int = 1, parMax: int = 1, modal: int = 2) -> CTBN:
+  """
+  Generates a random CTBN using Prufer's sequence.
+  Note : as diagonal coefficents are the negative sum of the coefficients one the line in a CIM,
+  their value does not necessarily belong to ``valueRange``.
+
+  Parameters
+  ----------
+  valueRange : Tuple[float, float]
+      Range to choose values from when filling the CIMs.
+  n : int
+      Number of variables.
+  parMax : int
+      Maximum number of parents a variable can have.
+  modal : int
+      Number of states a variable has (domain size).
+
+  Returns
+  -------
+  CTBN
+      A randomly generated ctbn.
+  """
+  ctbn = CTBN()
+
+  graph = pyagrum.MixedGraph()
+
+  for i in range(n):
+    name = f"V{i + 1}"
+    labels = [f"v{i + 1}_{t}" for t in range(1, modal + 1)]
+    var = pyagrum.LabelizedVariable(name, name, labels)
+    ctbn.add(var)
+    graph.addNode()
+
+  # generating Prufer's sequence and associated tree
+  if n == 2:
+    if random.random() > 0.5:
+      graph.addArc(0, 1)
+    else:
+      graph.addArc(1, 0)
+
+  elif n > 2:
+    sequence = [random.randint(0, n - 1) for _ in range(n - 2)]
+    degree = {id: 1 for id in range(0, n)}
+    par = {id: 0 for id in range(0, n)}
+    for i in range(n - 2):
+      degree[sequence[i]] += 1
+
+    for i in range(n - 2):
+      for j in range(n):
+        if degree[j] == 1:
+          graph.addEdge(j, sequence[i])
+          par[j] += 1
+          par[sequence[i]] += 1
+          degree[sequence[i]] -= 1
+          degree[j] -= 1
+          break
+
+    u = 0
+    v = 0
+    for i in range(n):
+      if degree[i] == 1:
+        if u == 0:
+          u = i
+        else:
+          v = i
+          break
+
+    graph.addEdge(u, v)
+
+    # direct it
+    directTree(graph, random.randint(0, n - 1))
+
+  # add/remove/invert arcs at random
+
+  for i in range(n * 3):
+    event = random.sample(range(0, n), k=2)
+    draw = random.randint(1, 3)
+
+    if draw == 1:
+      if len(graph.parents(event[1])) < parMax:
+        graph.addArc(event[0], event[1])
+
+    elif draw == 2:
+      if graph.existsArc(event[0], event[1]):
+        graph.eraseArc(event[0], event[1])
+        if len(graph.connectedComponents()) > 1:
+          graph.addArc(event[0], event[1])
+
+    else:
+      if graph.existsArc(event[0], event[1]):
+        if len(graph.parents(event[0])) < parMax:
+          graph.eraseArc(event[0], event[1])
+          graph.addArc(event[1], event[0])
+
+  # add arcs to the CTBN
+  for arc in graph.arcs():
+    ctbn.addArc(arc[0], arc[1])
+
+  randomCIMs(ctbn, valueRange)
+
+  return ctbn

pyagrum/ctbn/CTBNInference.py

@@ -0,0 +1,459 @@
+############################################################################
+#   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 csv
+from concurrent.futures import ProcessPoolExecutor
+from typing import Dict, Tuple
+from numpy.random import default_rng, choice
+from scipy.linalg import expm
+
+import pyagrum
+
+from pyagrum.ctbn import CIM
+from pyagrum.ctbn import CTBN
+from pyagrum.ctbn.constants import NodeId, NameOrId
+
+"""
+This file contains inference tools for CTBNs
+"""
+
+
+class CTBNInference:
+  """
+  Class CtbnInference includes tools for inference calculation : exact inference through amalgamation
+  and (forward) sampling inference.
+
+  Parameters
+  ----------
+  model : CTBN
+      The CTBN used for inference.
+  """
+
+  def __init__(self, model: CTBN):
+    self._model = model
+
+  def makeInference(self):
+    raise NotImplementedError("Not yet implemented.")
+
+  def posterior(self, name: str) -> "pyagrum.Tensor":
+    raise NotImplementedError("Not yet implemented.")
+
+
+class SimpleInference(CTBNInference):
+  """
+  Exact inference using amalgamation to compute the Intensity Matrix corresponding to the CTBN
+  (not efficient for models with great number of variables)
+
+  Parameters
+  ----------
+  ctbn : CTBN
+      The CTBN used for simple inference.
+  """
+
+  def __init__(self, ctbn: CTBN):
+    super().__init__(ctbn)
+    self._joint = None
+
+  def setEvidence(self, evs=None):
+    raise NotImplementedError("Not yet implemented.")
+
+  def makeInference(self, t: float = 5000):
+    """
+    Compute exact inference at time ``t``. Distribution for initial state is uniform.
+
+    Parameters
+    ----------
+    t : float
+        Time to make inference calculation at.
+    """
+    q = CIM()
+    # amalgamation
+    for nod in self._model.nodes():
+      q = q.amalgamate(self._model.CIM(nod))
+
+    q.fromMatrix(expm(t * q.toMatrix()))
+    # initial state distribution
+    t0 = pyagrum.Tensor()
+    for n in q.varNames:
+      if n[-1] == "i":
+        t0.add(q._pot.variable(n))
+    t0.fillWith(1).normalize()
+
+    self._joint = (t0 * q._pot).sumOut(list(t0.names))
+
+  def posterior(self, v: NameOrId) -> "pyagrum.Tensor":
+    """
+    Parameters
+    ----------
+    v : NameOrId
+        Name or id of the variable.
+
+    Returns
+    -------
+    pyagrum.Tensor
+        The computed distribution of variable ``v`` using exact inference.
+    """
+    vj = CIM.varJ(self._model.variable(v).name())
+    return pyagrum.Tensor().add(self._model.variable(v)).fillWith(self._joint.sumIn(vj), [vj])
+
+
+class ForwardSamplingInference(CTBNInference):
+  """
+  Inference using forward sampling (slow convergence).
+
+  Notes
+  -----
+  Sometimes samples are called trajectories. One sample is one trajectory.
+  When making inference, the last sample is stored in the class as a trajectory.
+  idtraj indicates the number of samplings done.
+
+  Parameters
+  ----------
+  ctbn : CTBN
+      The CTBN used for sampling.
+
+  Attributes
+  ----------
+  idtraj : int
+      Id of the sample.
+  trajectory : List[Tuple[float, str, str]]
+      Contains the trajectory from the last sampling.
+
+  Examples
+  --------
+  How to read a trajectory?
+  A tuple ``(t, var, s)`` means that at time ``t`` the variable ``var`` transition from state ``s`` to another one.
+
+  When storing many trajectories from different samples, a trajectory is identified by an id.
+  """
+
+  def __init__(self, ctbn: CTBN):
+    self.trajectory = list()
+    self.idtraj = 0
+    super().__init__(ctbn)
+    self._posteriors = {nod: pyagrum.Tensor().add(self._model.variable(nod)) for nod in self._model.names()}
+
+  def makeSample(self, posteriors: Dict[str, pyagrum.Tensor], timeHorizon: float = 5000, burnIn: int = 100) -> int:
+    """
+    Fills posteriors using forward sampling.
+
+    Parameters
+    ----------
+    posteriors : Dict[str, pyagrum.Tensor]
+        A dict containing a posterior for each variable of the CTBN.
+    timeHorizon : float
+        Duration of the sampling.
+    burnIn : int
+        Number of runs before starting the sampling (to ensure ergodicity).
+
+    Returns
+    -------
+    int
+        Number of runs.
+    """
+
+    def init(current):
+      """
+      Initializes posteriors and draw the initial values of each variable using uniform distribution.
+
+      Parameters
+      ----------
+      current : pyagrum.Instantiation
+          An instance of the variables of the CTBN.
+      """
+      for nam in self._model.names():
+        posteriors[nam].fillWith(0)
+
+      # initial uniform distribution for each variable
+      for nod in self._model.nodes():
+        v = self._model.variable(nod)
+        newval = int(choice(range(v.domainSize())))
+        current.chgVal(v.name(), newval)
+        posteriors[v.name()][newval] = 1
+
+    def getNextEvent(current: pyagrum.Instantiation, indice: pyagrum.Instantiation) -> Tuple[NodeId, float]:
+      """
+      Chooses the next variable to change value. The variable is chosen by drawing values of all of the variables transition
+      time (i.e how much time does a variable stay in the same state). Those durations follow an exponential distribution.
+      The variable with the shortest transition time is chosen.
+
+      Parameters
+      ----------
+      current : pyagrum.Instantiation
+          An instance of the variables in the CTBN.
+      indice : pyagrum.Instantiation
+          An instance of the variables in the CTBN plus their from_state/to_state corresponding variables.
+
+      Returns
+      -------
+      Tuple[NodeId, float]
+          The nodeId and transition time of the variable with the lowest transition time.
+      """
+      indice.setVals(current)
+      # compute next variable event
+      dt = None
+      argmin = None
+      for nod in self._model.nodes():
+        v = self._model.variable(nod)
+        indice.chgVal(CIM.varI(v.name()), indice.val(v))
+        indice.chgVal(CIM.varJ(v.name()), indice.val(v))  # just the diagonal
+
+        v_lambda = -self._model.CIM(nod)[indice]
+        if v_lambda != 0:
+          d = rand.exponential(1 / v_lambda)
+          if dt is None or dt > d:
+            dt = d
+            argmin = nod
+
+      return (argmin, dt)
+
+    def sampleNextState(current: pyagrum.Instantiation, indice: pyagrum.Instantiation, nextEvt: NameOrId) -> str:
+      """
+      Draw the next state of the variable nextEvt using uniform distribution over its states.
+      ``current`` will contain the new value of ``nextEvt``.
+
+      Parameters
+      ----------
+      current : pyagrum.Instantiation
+          An instantiation of the variables in the ctbn to contain the new value of nextEvt.
+      indice : pyagrum.Instantiation
+          An instance of the variables in the ctbn plus their from_state/to_state corresponding variables.
+      nextEvt : NameOrId
+          Name of id of the next variable to change state.
+
+      Returns
+      -------
+      str
+          Name of the variable.
+      """
+      v = self._model.variable(nextEvt)
+      indice.chgVal(CIM.varI(v.name()), indice.val(v))
+      indice.chgVal(CIM.varJ(v.name()), indice.val(v))  # just the diagonal
+
+      somme = -self._model.CIM(nextEvt)[indice]
+      choices = []
+      probas = []
+      for j in range(v.domainSize()):
+        if j != indice.val(v):  # not the diagonal
+          choices.append(j)
+          indice.chgVal(CIM.varJ(v.name()), j)
+          probas.append(self._model.CIM(nextEvt)[indice] / somme)
+
+      newval = int(choice(choices, p=probas))
+      current.chgVal(v.name(), newval)
+      return v.name()
+
+    # start
+    current = self._model.completeInstantiation()
+    rand = default_rng()
+    nb_events = 0
+    indice = self._model.fullInstantiation()
+    init(current)  # initialize the starting value of each variable
+
+    # BURNIN
+    while nb_events < burnIn:
+      # find next variable which will change its value
+      nextEvt, dt = getNextEvent(current, indice)
+      if nextEvt is None:  # if none of variables changes
+        pass
+      else:
+        # find the value of the variable which will change its value and let this variable update his value
+        sampleNextState(current, indice, nextEvt)
+        nb_events += 1  # an event means a variable changes its value
+
+    # SAMPLING
+    duration = 0
+    for name in self._model.names():
+      current_state = self._model.variable(name).label(current.val(self._model.variable(name)))
+      self.trajectory.append((0, name, current_state))
+    while True:
+      nextEvt, dt = getNextEvent(current, indice)
+
+      # if none of variables changes before the timeHorizon (or just doesn't change at all)
+      if duration + dt > timeHorizon or nextEvt is None:
+        # update everyone for last event
+        for name in self._model.names():
+          posteriors[name][current] += timeHorizon - duration
+          current_state = self._model.variable(name).label(current.val(self._model.variable(name)))
+          self.trajectory.append((timeHorizon, name, current_state))
+        break  # arriving at the timeHorizon, we quit the loop
+
+      # update posteriors
+      for name in self._model.names():
+        posteriors[name][current] += dt
+      duration += dt
+
+      # add event to trajectory
+      current_state = self._model.variable(nextEvt).label(current.val(self._model.variable(nextEvt)))
+      self.trajectory.append((duration, self._model.name(nextEvt), current_state))
+
+      sampleNextState(current, indice, nextEvt)
+      nb_events += 1
+
+    return nb_events
+
+  def makeInference(self, timeHorizon: float = 5000, burnIn: int = 100) -> int:
+    """
+    Start a new sample and normalize resulting posteriors to get an aproximation of the inference.
+
+    Parameters
+    ----------
+    timeHorizon : float
+        Duration of the sampling.
+    burnIn : int
+        Number of runs before starting the sampling (to ensure ergodicity).
+
+    Returns
+    -------
+    int
+        Number of runs.
+    """
+    self.idtraj += 1
+    self.trajectory = list()
+    res = self.makeSample(self._posteriors, timeHorizon, burnIn)
+    for nam in self._model.names():
+      self._posteriors[nam].normalize()
+    return res
+
+  def makeParallelInference(self, nbTrajectories: int = 5, timeHorizon: float = 5000, burnIn: int = 100):
+    """
+    Start a given number of sample and approximate the inference over all the samples.
+
+    Parameters
+    ----------
+    nbTrajectories : int
+        Number of sampling in parallel.
+    timeHorizon : float
+        Duration of the sampling.
+    burnIn : int
+        Number of runs before starting the sampling (to ensure ergodicity).
+    """
+    posteriorsList = [
+      {nod: pyagrum.Tensor().add(self._model.variable(nod)) for nod in self._model.names()}
+      for _ in range(nbTrajectories)
+    ]
+
+    def runMakeSample(task: int):
+      res = self.makeSample(posteriorsList[task], timeHorizon, burnIn)
+      return res
+
+    with ProcessPoolExecutor(max_workers=1000) as executor:
+      future = {executor.submit(runMakeSample, task) for task in range(nbTrajectories)}
+
+    print([f.result() for f in future])
+
+    for nam in self._model.names():
+      self._posteriors[nam].fillWith(0)
+      for i in range(nbTrajectories):
+        self._posteriors[nam] += posteriorsList[i][nam]
+      self._posteriors[nam].normalize()
+
+  def averageInference(self, nbTrajectories: int = 5, timeHorizon: float = 5000, burnIn: int = 100):
+    """
+    Start ``nbTrajectories`` sampling and approximate the inference over all samples.
+
+    Parameters
+    ----------
+    nbTrajectories: int
+        Number of sampling in parallel.
+    timeHorizon : float
+        Duration of the sampling.
+    burnIn : int
+        Number of runs before starting the sampling (to ensure ergodicity).
+    """
+    posteriorsList = [
+      {nod: pyagrum.Tensor().add(self._model.variable(nod)) for nod in self._model.names()}
+      for _ in range(nbTrajectories)
+    ]
+
+    for i in range(nbTrajectories):
+      self.makeSample(posteriorsList[i], timeHorizon, burnIn)
+
+    for nam in self._model.names():
+      self._posteriors[nam].fillWith(0)
+      for i in range(nbTrajectories):
+        self._posteriors[nam] += posteriorsList[i][nam]
+      self._posteriors[nam].normalize()
+
+  def posterior(self, name: str) -> "pyagrum.Tensor":
+    """
+    Parameters
+    ----------
+    name : str
+        Name of the variable.
+
+    Returns
+    -------
+    pyagrum.Tensor
+        The aproximate inference of a given variable.
+    """
+    p = pyagrum.Tensor(self._posteriors[name])
+    p._model = self._model
+    return p
+
+  def writeTrajectoryCSV(self, filename: str, n: int = 1, timeHorizon=10, burnIn=100):
+    """
+    Makes ``n`` samples using Forward Sampling and saves trajectories into a csv file.
+    Storing format : {IdSample, time, Var, state}
+
+    Parameters
+    ----------
+    filename : str
+        Name of the file to save trajectories in.
+    n : int
+        Number of sampling to run.
+    timeHorizon : float
+        Duration of the sampling.
+    burnIn : int
+        Number of preliminary iterations before starting.
+    """
+    data = dict()
+    for i in range(n):
+      self.makeInference(timeHorizon=timeHorizon, burnIn=burnIn)
+      data[i] = self.trajectory
+
+    with open(filename, "w", newline="") as csvfile:
+      fieldnames = ["IdSample", "time", "var", "state"]
+      writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+      writer.writeheader()
+      for i in range(len(data)):
+        for tr in data[i]:
+          writer.writerow({"IdSample": str(i), "time": str(tr[0]), "var": tr[1], "state": tr[2]})