Skip to content

Using Continuous-Time Bayesian Networks

Creative Commons LicenseaGrUMinteractive online version
import pyagrum as gum
import pyagrum.ctbn as ct
import pyagrum.ctbn.notebook as ctbnnb
import pyagrum.lib.notebook as gnb

A CTBN(Continuous-Time Bayesian Networks) is a graphical model that allows a Bayesian Network to evolve over continuous time.

(For more details see https://pyagrum.readthedocs.io/en/latest/ctbn.html)

## 1. Creating the ctbn
ctbn = ct.CTBN()
## 2. Adding the random variables
ctbn.add(gum.LabelizedVariable("cloudy?", "cloudy?"))
ctbn.add(gum.LabelizedVariable("rain?", "rain?"))
## 3. Adding the arcs
ctbn.addArc("cloudy?", "rain?")
ctbn.addArc("rain?", "cloudy?")
## 4. Filling the CIMS (Conditional Intensity Matrixes)
ctbn.CIM("cloudy?")[{"rain?": "0"}] = [[-0.1, 0.1], [1, -1]]
ctbn.CIM("cloudy?")[{"rain?": "1"}] = [[-100, 100], [0.5, -0.5]]
ctbn.CIM("rain?")[{"cloudy?": "0"}] = [[-0.5, 0.5], [1000, -1000]]
ctbn.CIM("rain?")[{"cloudy?": "1"}] = [[-2, 2], [2, -2]]
## 5. Plotting the CTBN (whith/whithout the CIMs)
ctbnnb.showCtbnGraph(ctbn)
ctbnnb.showCIMs(ctbn)

svg

cloudy?#j
rain?
cloudy?#i
0
1
0
0
-0.10000.1000
1
1.0000-1.0000
1
0
-100.0000100.0000
1
0.5000-0.5000

CIM(cloudy?)
rain?#j
cloudy?
rain?#i
0
1
0
0
-0.50000.5000
1
1000.0000-1000.0000
1
0
-2.00002.0000
1
2.0000-2.0000

CIM(rain?)

cloudy?#i gives the state cloudy? is currently in and cloudy?#j gives its next state.

The CIM object, built around a pyagrum.Tensor is used to store the parameters of the variables, describing the waiting time before switching to another state.

A useful tool for CIMs, mainly used for simple inference, is amalgamation. It allows to merge many CIMs into one.

cimA = ctbn.CIM("cloudy?")
cimB = ctbn.CIM("rain?")
amal = cimA.amalgamate(cimB) # or cimA * cimB
amal.getTensor() # as a Tensor
cloudy?#i
rain?#i
cloudy?#j
rain?#j
0
1
0
0
0
-0.60001.0000
1
0.50000.0000
1
0
0.1000-3.0000
1
0.00002.0000
1
0
0
1000.00000.0000
1
-1100.00000.5000
1
0
0.00002.0000
1
100.0000-2.5000
print("\nJoint intensity matrix as numpy array\n")
print(amal.toMatrix()) # as a numpy array
Joint intensity matrix as numpy array
[[-6.0e-01 1.0e-01 5.0e-01 0.0e+00]
[ 1.0e+00 -3.0e+00 0.0e+00 2.0e+00]
[ 1.0e+03 0.0e+00 -1.1e+03 1.0e+02]
[ 0.0e+00 2.0e+00 5.0e-01 -2.5e+00]]

A random variable of a ctbn can be identified by either its name or id.

In any case, most class functions parameters allow for a variable to be identified by either its name or id (type NameOrId).

labels_with_id = ctbn.labels(0)
labels_with_name = ctbn.labels("cloudy?")
print(f"labels using id : {labels_with_id}, using name : {labels_with_name}")
variable_with_id = ctbn.variable(0)
variable_with_name = ctbn.variable("cloudy?")
print(f"The variables 0 and 'cloudy?' are the same ? {variable_with_id == variable_with_name}")
labels using id : ('0', '1'), using name : ('0', '1')
The variables 0 and 'cloudy?' are the same ? True

All functions with NameOrId parameters work the same way

The CtbnGenerator module can be used to quickly generate CTBNs. The parameters value are drawn at random from a value range. The diagonal coefficients are just the negative sum of the ones on the same line (in a CIM). It is also possible to choose the number of variables, the maximum number of parents a variable can have, and the domain size of the variables.

randomCtbn = ct.randomCTBN(valueRange=(1, 10), n=8, parMax=2, modal=2)
ctbnnb.showCtbnGraph(randomCtbn)
ctbnnb.showCIMs(randomCtbn)

svg

V1#j
V2
V1#i
v1_1
v1_2
v2_1
v1_1
-5.61995.6199
v1_2
2.1084-2.1084
v2_2
v1_1
-3.66293.6629
v1_2
5.0616-5.0616

CIM(V1)
V2#j
V1
V2#i
v2_1
v2_2
v1_1
v2_1
-5.97295.9729
v2_2
6.7560-6.7560
v1_2
v2_1
-7.47017.4701
v2_2
9.2910-9.2910

CIM(V2)
V3#j
V6
V1
V3#i
v3_1
v3_2
v6_1
v1_1
v3_1
-2.83192.8319
v3_2
4.6710-4.6710
v1_2
v3_1
-7.36757.3675
v3_2
5.0663-5.0663
v6_2
v1_1
v3_1
-1.99581.9958
v3_2
8.3041-8.3041
v1_2
v3_1
-7.23967.2396
v3_2
9.2639-9.2639

CIM(V3)
V4#j
V7
V3
V4#i
v4_1
v4_2
v7_1
v3_1
v4_1
-7.82827.8282
v4_2
3.1545-3.1545
v3_2
v4_1
-2.59312.5931
v4_2
2.1456-2.1456
v7_2
v3_1
v4_1
-5.46655.4665
v4_2
9.6721-9.6721
v3_2
v4_1
-7.72757.7275
v4_2
7.6130-7.6130

CIM(V4)
V5#j
V4
V8
V5#i
v5_1
v5_2
v4_1
v8_1
v5_1
-7.84657.8465
v5_2
4.5868-4.5868
v8_2
v5_1
-1.81271.8127
v5_2
3.9380-3.9380
v4_2
v8_1
v5_1
-1.51821.5182
v5_2
9.6412-9.6412
v8_2
v5_1
-2.99612.9961
v5_2
7.1567-7.1567

CIM(V5)
V6#j
V1
V2
V6#i
v6_1
v6_2
v1_1
v2_1
v6_1
-8.86608.8660
v6_2
3.0004-3.0004
v2_2
v6_1
-1.68571.6857
v6_2
8.1480-8.1480
v1_2
v2_1
v6_1
-3.26403.2640
v6_2
8.0823-8.0823
v2_2
v6_1
-3.07723.0772
v6_2
7.6199-7.6199

CIM(V6)
V7#j
V4
V7#i
v7_1
v7_2
v4_1
v7_1
-7.37147.3714
v7_2
4.1753-4.1753
v4_2
v7_1
-4.45984.4598
v7_2
2.2773-2.2773

CIM(V7)
V8#j
V2
V8#i
v8_1
v8_2
v2_1
v8_1
-1.59751.5975
v8_2
6.9423-6.9423
v2_2
v8_1
-7.53627.5362
v8_2
2.4653-2.4653

CIM(V8)

Exact inference & Forward Sampling inference

Section titled “Exact inference & Forward Sampling inference”
  • Amalgamation is used to compute exact inference. It consists in merging all the CIMs of a CTBN into one CIM. Then we use the properties of markov process : P(Xt)=P(X0)∗exp(QXt)P(X_t) = P(X_0)*exp(Q_Xt) for enough time to notice convergence.

  • Forward sampling works this way:

    • At time tt :
    • Draw a “time until next change” dtdt value for each variable’s exponential distribution of their waiting time.
    • Select the variable with smallest transition time : nexttime=t+dtnext time = t + dt.
    • Draw the variable next state uniformly.
    • loop until t=timeHorizont = timeHorizon.

When doing forward sampling, we first iterate this process over a given amount of iterations (called burnIn). We consider the last values as the initial configuration for sampling. The reason is that the initial state of a CTBN is unknown without real data.

## 1. Initialiaze Inference object
ie = ct.SimpleInference(ctbn)
ie_forward = ct.ForwardSamplingInference(ctbn)
gnb.sideBySide(ctbnnb.getCtbnGraph(ctbn), ctbnnb.getCtbnInference(ctbn, ie), ctbnnb.getCtbnInference(ctbn, ie_forward))
ctbn cloudy? cloudy? rain? rain? cloudy?->rain? rain?->cloudy?
structs Inference in   0.79ms cloudy? 2026-10-27T15:22:28.371464 image/svg+xml Matplotlib v3.11.2, rain? 2026-10-27T15:22:28.387739 image/svg+xml Matplotlib v3.11.2, cloudy?->rain? rain?->cloudy?
structs Inference in 201.66ms cloudy? 2026-10-27T15:22:28.734060 image/svg+xml Matplotlib v3.11.2, rain? 2026-10-27T15:22:28.752154 image/svg+xml Matplotlib v3.11.2, cloudy?->rain? rain?->cloudy?

In any case, inference can be made using makeInference() function from every Inference object.

import time
## Simple inference
time1 = time.time()
ie.makeInference(t=5000)
pot1 = ie.posterior("cloudy?")
elapsed1 = time.time() - time1
## Sampling inference
time2 = time.time()
ie_forward.makeInference(timeHorizon=5000, burnIn=100)
pot2 = ie_forward.posterior("cloudy?")
elapsed2 = time.time() - time2
gnb.sideBySide(
gnb.getTensor(pot1),
gnb.getTensor(pot2),
captions=[f"Simple inference {round(elapsed1 * 1000, 2)} ms", f"Sampling inference {round(elapsed2 * 1000, 2)} ms"],
)
cloudy?
0
1
0.83340.1666

Simple inference 2.75 ms
cloudy?
0
1
0.82640.1736

Sampling inference 214.23 ms

Here is an example of a trajectory plot

## 1_1. Find trajectory stored in the inference class
ie_forward.makeInference()
traj = ie_forward.trajectory # a single trajectory list[tuple[float, str, str]]
## 1_2. Or find it in a csv file
ie_forward.writeTrajectoryCSV("out/trajectory.csv", n=1, timeHorizon=1000, burnIn=100) # to save a trajectory
traj = ct.readTrajectoryCSV("out/trajectory.csv") # a dict of trajectories
## 2. Plot the trajectory
ct.plotTrajectory(ctbn.variable("cloudy?"), traj[0], timeHorizon=40, plotname="plot of cloudy?")

svg

It is also possible to plot the proportions of the states a variable is in over time.

Let’s take the exemple of a variable with domain size=5.

## 1. Create CTBN
new_ctbn = ct.CTBN()
X = gum.LabelizedVariable("X", "X", ["a1", "a2", "a3", "a4", "a5"])
new_ctbn.add(X)
new_ctbn.CIM("X")[:] = [
[-10, 2, 4, 0, 4],
[0.5, -1, 0.5, 0, 0],
[5, 0.5, -10, 3.5, 1],
[50, 0.5, 50, -200.5, 100],
[1, 0, 2, 7, -10],
]
## 2. Sampling
ieX = ct.ForwardSamplingInference(new_ctbn)
ieX.writeTrajectoryCSV("out/traj_quinary.csv", n=3, timeHorizon=100)
trajX = ct.readTrajectoryCSV("out/traj_quinary.csv")
## 3. Plotting
ct.plotFollowVar(X, trajX)

svg

The ctbn library has tools to learn the graph of a CTBN as well as the CIMs of its variables

From a sample, we can find the variables name and their labels. However, if the sample is too short, it is possible that some information may be missed.

newCtbn = ct.CTBNFromData(traj)
print("variables found and their labels")
for name in newCtbn.names():
print(f"variable {name}, labels : {newCtbn.labels(name)}")
variables found and their labels
variable rain?, labels : ('0', '1')
variable cloudy?, labels : ('0', '1')
## 1. Create a Learner.
learner = ct.Learner("out/trajectory.csv")
## 2. Run learning algorithm
learned_ctbn = learner.learnCTBN()
## 3. Plot the learned CTBN
gnb.show(learned_ctbn)

svg

Let’s note that having a test object is necessary since we want to be able to test independency between variables. For now only 2 tests are available : (Fisher and Chi2) test and Oracle test. Oracle test is only used for benchmarking since it uses the initial ctbn as a reference.

It is also possible to approximate the transition time distributions of each variable, i.e the CIMs.

Note that conditioning variables are taken from the ctbn.

cims_before = ctbnnb.getCIMs(ctbn)
learner.fitParameters(ctbn)
cims_after = ctbnnb.getCIMs(ctbn)
gnb.sideBySide(cims_before, cims_after, captions=["original CIMs", "learned CIMs"])
cloudy?#j
rain?
cloudy?#i
0
1
0
0
-0.10000.1000
1
1.0000-1.0000
1
0
-100.0000100.0000
1
0.5000-0.5000

CIM(cloudy?)
rain?#j
cloudy?
rain?#i
0
1
0
0
-0.50000.5000
1
1000.0000-1000.0000
1
0
-2.00002.0000
1
2.0000-2.0000

CIM(rain?)

original CIMs
cloudy?#j
rain?
cloudy?#i
0
1
0
0
-0.10800.1080
1
0.9430-0.9430
1
0
-97.529097.5290
1
0.3890-0.3890

CIM(cloudy?)
rain?#j
cloudy?
rain?#i
0
1
0
0
-0.49600.4960
1
997.7940-997.7940
1
0
-1.77401.7740
1
1.9650-1.9650

CIM(rain?)

learned CIMs

This example comes from :

U. Nodelman, C.R. Shelton, and D. Koller (2003). "Learning Continuous Time Bayesian Networks." Proc. Nineteenth Conference on Uncertainty in Artificial Intelligence (UAI) (pp. 451-458).
## 1. Creating the ctbn
drugEffect = ct.CTBN()
drugEffect.add(gum.LabelizedVariable("Eating", ""))
drugEffect.add(gum.LabelizedVariable("Hungry", ""))
drugEffect.add(gum.LabelizedVariable("Full stomach", ""))
drugEffect.add(gum.LabelizedVariable("Uptake", ""))
drugEffect.add(gum.LabelizedVariable("Concentration", "?"))
drugEffect.add(gum.LabelizedVariable("Barometer", ""))
drugEffect.add(gum.LabelizedVariable("Joint pain", ""))
drugEffect.add(gum.LabelizedVariable("Drowsy", ""))
drugEffect.addArc("Hungry", "Eating")
drugEffect.addArc("Eating", "Full stomach")
drugEffect.addArc("Full stomach", "Hungry")
drugEffect.addArc("Full stomach", "Concentration")
drugEffect.addArc("Uptake", "Concentration")
drugEffect.addArc("Concentration", "Drowsy")
drugEffect.addArc("Barometer", "Joint pain")
drugEffect.addArc("Concentration", "Joint pain")
gnb.show(drugEffect)

svg

from pyagrum.ctbn.CTBNGenerator import randomCIMs
randomCIMs(drugEffect, (0.1, 10))
drugEffect.CIM("Eating")[{"Hungry": 0}] = [[-0.1, 0.1], [10, -10]]
drugEffect.CIM("Eating")[{"Hungry": 1}] = [[-2, 2], [0.1, -0.1]]
drugEffect.CIM("Full stomach")[{"Eating": 0}] = [[-0.1, 0.1], [10, -10]]
drugEffect.CIM("Full stomach")[{"Eating": 1}] = [[-2, 2], [0.1, -0.1]]
drugEffect.CIM("Hungry")[{"Full stomach": 0}] = [[-0.1, 0.1], [10, -10]]
drugEffect.CIM("Hungry")[{"Full stomach": 1}] = [[-2, 2], [0.1, -0.1]]
ieX = ct.ForwardSamplingInference(drugEffect)
ieX.writeTrajectoryCSV("out/drugEffect.csv", n=3, timeHorizon=100)
trajX = ct.readTrajectoryCSV("out/drugEffect.csv")
ct.plotFollowVar(drugEffect.variable("Hungry"), trajX)
ct.plotFollowVar(drugEffect.variable("Full stomach"), trajX)
ct.plotFollowVar(drugEffect.variable("Eating"), trajX)
ct.plotFollowVar(drugEffect.variable("Concentration"), trajX)

svg

svg

svg

svg

import pickle
with open("out/testCTBN.pkl", "bw") as f:
pickle.dump(drugEffect, f)
drugEffect
ctbn Eating Eating Full stomach Full stomach Eating->Full stomach Hungry Hungry Hungry->Eating Full stomach->Hungry Concentration Concentration Full stomach->Concentration Uptake Uptake Uptake->Concentration Joint pain Joint pain Concentration->Joint pain Drowsy Drowsy Concentration->Drowsy Barometer Barometer Barometer->Joint pain
with open("out/testCTBN.pkl", "br") as f:
copyDrug = pickle.load(f)
copyDrug
ctbn Eating Eating Full stomach Full stomach Eating->Full stomach Hungry Hungry Hungry->Eating Full stomach->Hungry Concentration Concentration Full stomach->Concentration Uptake Uptake Uptake->Concentration Joint pain Joint pain Concentration->Joint pain Drowsy Drowsy Concentration->Drowsy Barometer Barometer Barometer->Joint pain