Updating a PGMPY Bayesian Network with new partial evidences

[sachinsdesai]

Folks, I looked thru all the issues, discussions and the notebooks - but could not find an answer. Hence posting it here.

I have a use-case where I have built a Bayesian Network using static CPDs (not using data, but using "expert knowledge"). I am able to make inferences using pgmpy.estimators.MaximumLikelihoodEstimator().map_query - to get expected results. But I am unable to figure out how to accomplish a specific need that I have:

1. I have continuous incoming partial evidence for different subsets of nodes in the network (one update may have only A,B,C values, another may have A,C,Z and so on). I would like to update the network with this continuously
2. I want to have control on how much the new incoming (partial) evidence should weigh in on updating the CPDs of the table

With some help from various sources, I tried different things (for example, the fit_update() method). It doesn't seem to work for me. When I called fit_update with new partial evidence, it updated the CPD (for the variable that I am interested in) once and after that, never updated it even with a wide range of values for different variables. I played with the n_prev_samples and all that, but nothing helped. I am sure this isn't the right method and I am missing something basic here. Any pointers would be of great help.

[sachinsdesai]

More specifically, I am looking for the equivalent of the following operation that is supported in PYBBN (or any other way to accomplish this):

ev = EvidenceBuilder() \
    .with_node(join_tree.get_bbn_node_by_name(nod)) \
    .with_evidence(cat, val) \
    .build()
    join_tree.set_observation(ev)

[sachinsdesai]

@ankurankan , I just noticed that the last discussion thread here was in Jan 2022. Is there a different place where I can ask questions like these? Pls let me know. I am stuck at this place and it is a fairly critical blocker. Combed thru various places where PGMPY discussions are happening and could not find anything. ChatGPT and Bard had very convoluted guidance. Thought I would come straight to the source.

Any help would be greatly appreciated.

[ankurankan]

@sachinsdesai Sorry, as I am the only one maintaining the package right now, replies can be a bit slow at times. I will just add what I mentioned over email here as well, just in case anyone else has a similar use case.
The fit_update method should be able to update the model with new data. But it assumes a couple of things:

1. That the model already has all the possible states that we are going to observe in datasets used for updation
2. There are no missing values.

As you mentioned that the data you are using to update has missing values, the easiest way would be to do data imputation. A couple of ways are possible:

1. Preserving the marginal distributions of the missing variables: For this, we can simulate the missing values from the marginal distributions of the missing variables.
2. Preserving the conditional distribution: For this, we can use the new dataset as evidence to compute the conditional distributions of the missing values and sample data from that.

Lastly, another possibility is to use the EM algorithm to learn the model parameters from data with missing values and then somehow combine it with the model learned from expert knowledge. There is no direct method to do this in pgmpy right now.

[ankurankan]

@sachinsdesai I wrote an example that might be helpful.

1. Creating an example model and a new data point with some missing values.

In [1]: from pgmpy.utils import get_example_model

# Build a model; equivalent to the model built on expert knowledge
In [2]: model = get_example_model('alarm')

# Creating a new data point which can be used to update the model; equivalent to the new incoming data.
In [5]: new_data = model.simulate(1, evidence={'VENTALV': 'NORMAL', 'ARTCO2': 'HIGH'})
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  4.97it/s]

In [6]: new_data
Out[6]: 
  ERRCAUTER   SHUNT LVFAILURE HRBP MINVOL  CVP   BP SAO2 VENTLUNG     TPR    FIO2 VENTTUBE   CO   HRSAT PVSAT INTUBATION LVEDVOLUME     PAP EXPCO2 ANAPHYLAXIS DISCONNECT MINVOLSET INSUFFANESTH CATECHOL HISTORY VENTALV VENTMACH HYPOVOLEMIA HREKG   PRESS PULMEMBOLUS      HR PCWP ARTCO2 KINKEDTUBE STROKEVOLUME ERRLOWOUTPUT
0     FALSE  NORMAL      TRUE  LOW    LOW  LOW  LOW  LOW   NORMAL  NORMAL  NORMAL      LOW  LOW  NORMAL   LOW     NORMAL        LOW  NORMAL   ZERO       FALSE      FALSE    NORMAL        FALSE     HIGH    TRUE  NORMAL   NORMAL        TRUE   LOW  NORMAL       FALSE  NORMAL  LOW   HIGH      FALSE          LOW        FALSE

# Simulate missing values for the new data.
In [7]: new_data.SHUNT = np.NaN

In [8]: new_data.CO = np.NaN

In [9]: new_data
Out[9]: 
  ERRCAUTER  SHUNT LVFAILURE HRBP MINVOL  CVP   BP SAO2 VENTLUNG     TPR    FIO2 VENTTUBE  CO   HRSAT PVSAT INTUBATION LVEDVOLUME     PAP EXPCO2 ANAPHYLAXIS DISCONNECT MINVOLSET INSUFFANESTH CATECHOL HISTORY VENTALV VENTMACH HYPOVOLEMIA HREKG   PRESS PULMEMBOLUS      HR PCWP ARTCO2 KINKEDTUBE STROKEVOLUME ERRLOWOUTPUT
0     FALSE    NaN      TRUE  LOW    LOW  LOW  LOW  LOW   NORMAL  NORMAL  NORMAL      LOW NaN  NORMAL   LOW     NORMAL        LOW  NORMAL   ZERO       FALSE      FALSE    NORMAL        FALSE     HIGH    TRUE  NORMAL   NORMAL        TRUE   LOW  NORMAL       FALSE  NORMAL  LOW   HIGH      FALSE          LOW        FALSE

We have created a model and a new data point which fits your usecase. The first solution I mentioned about imputing the missing values using their marginal distributions and then updating the model:

In [10]: missing_vars = ['SHUNT', 'CO']

In [11]: from pgmpy.inference import VariableElimination

In [12]: infer = VariableElimination(model)

# Doing inference to get the marginal distributions of the missing variables.
In [13]: missing_dist = infer.query(missing_vars, joint=False)

In [14]: missing_dist
Out[14]: 
{'SHUNT': <DiscreteFactor representing phi(SHUNT:2) at 0x7f9332197880>,
 'CO': <DiscreteFactor representing phi(CO:3) at 0x7f9329bbd8d0>}

In [15]: print(missing_dist['SHUNT'])
+---------------+--------------+
| SHUNT         |   phi(SHUNT) |
+===============+==============+
| SHUNT(NORMAL) |       0.8969 |
+---------------+--------------+
| SHUNT(HIGH)   |       0.1031 |
+---------------+--------------+

# Simulating data using the marginal distribution to impute in the new dataset
In [16]: np.random.choice(['NORMAL', 'HIGH'], p=missing_dist['SHUNT'].values)
Out[16]: 'NORMAL'

In [17]: new_data.SHUNT = np.random.choice(['NORMAL', 'HIGH'], p=missing_dist['SHUNT'].values)

In [18]: print(missing_dist['CO'])
+------------+-----------+
| CO         |   phi(CO) |
+============+===========+
| CO(LOW)    |    0.1723 |
+------------+-----------+
| CO(NORMAL) |    0.1845 |
+------------+-----------+
| CO(HIGH)   |    0.6432 |
+------------+-----------+

In [19]: new_data.CO = np.random.choice(['LOW', 'NORMAL', 'HIGH'], p=missing_dist['CO'].values)

# No missing values in the dataset after imputation.
In [20]: new_data
Out[20]: 
  ERRCAUTER   SHUNT LVFAILURE HRBP MINVOL  CVP   BP SAO2 VENTLUNG     TPR    FIO2 VENTTUBE   CO   HRSAT PVSAT INTUBATION LVEDVOLUME     PAP EXPCO2 ANAPHYLAXIS DISCONNECT MINVOLSET INSUFFANESTH CATECHOL HISTORY VENTALV VENTMACH HYPOVOLEMIA HREKG   PRESS PULMEMBOLUS      HR PCWP ARTCO2 KINKEDTUBE STROKEVOLUME ERRLOWOUTPUT
0     FALSE  NORMAL      TRUE  LOW    LOW  LOW  LOW  LOW   NORMAL  NORMAL  NORMAL      LOW  LOW  NORMAL   LOW     NORMAL        LOW  NORMAL   ZERO       FALSE      FALSE    NORMAL        FALSE     HIGH    TRUE  NORMAL   NORMAL        TRUE   LOW  NORMAL       FALSE  NORMAL  LOW   HIGH      FALSE          LOW        FALSE

In [21]: model.fit_update(new_data)

The second idea of imputing the value using the conditional distribution:

In [22]: new_data = model.simulate(1, evidence={'VENTALV': 'NORMAL', 'ARTCO2': 'HIGH'})                                                                                                                                                                                                                                                                     
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 17.33it/s]
                                                                                       
                                                                                                                                                                                                                                                                                                                                                            
In [24]: new_data.SHUNT = np.NaN                                                                                                                                                                                                                                                                                                                            
                                                                                       
In [25]: new_data.CO = np.NaN           

In [31]: evidence = new_data.dropna(axis=1).iloc[0, :].to_dict()

In [32]: cond_dist = infer.query(missing_vars, evidence=evidence, joint=False)

In [33]: cond_dist
Out[33]: 
{'SHUNT': <DiscreteFactor representing phi(SHUNT:2) at 0x7f93288cd540>,
 'CO': <DiscreteFactor representing phi(CO:3) at 0x7f9320b37a60>}

In [34]: new_data.SHUT = np.random.choice(['NORMAL', 'HIGH'], p=cond_dist['SHUNT'].values)

In [35]: new_data.SHUNT = np.random.choice(['NORMAL', 'HIGH'], p=cond_dist['SHUNT'].values)

In [36]: del new_data.SHUT

In [37]: new_data.CO = np.random.choice(['LOW', 'NORMAL', 'HIGH'], p=cond_dist['CO'].values)

In [38]: new_data
Out[38]: 
  ERRCAUTER   SHUNT LVFAILURE HRBP MINVOL   CVP      BP SAO2 VENTLUNG     TPR    FIO2 VENTTUBE      CO   HRSAT PVSAT INTUBATION LVEDVOLUME     PAP EXPCO2 ANAPHYLAXIS DISCONNECT MINVOLSET INSUFFANESTH CATECHOL HISTORY VENTALV VENTMACH HYPOVOLEMIA HREKG PRESS PULMEMBOLUS      HR  PCWP ARTCO2 KINKEDTUBE STROKEVOLUME ERRLOWOUTPUT
0     FALSE  NORMAL     FALSE  LOW   ZERO  HIGH  NORMAL  LOW   NORMAL  NORMAL  NORMAL      LOW  NORMAL  NORMAL   LOW     NORMAL       HIGH  NORMAL   ZERO       FALSE      FALSE    NORMAL        FALSE     HIGH   FALSE  NORMAL   NORMAL        TRUE   LOW  HIGH       FALSE  NORMAL  HIGH   HIGH      FALSE       NORMAL        FALSE

In [39]: model.fit_update(new_data)

[borjasor]

Hi @sachinsdesai and @ankurankan , I am looking for a similar 'network update' requirement based on observed evidence. It has been a year since this entry, I wonder if there is further suggestions to the ones provided above?

It is my understanding that the answers in this thread are intended to update the CPDs of the network considering the new evidence as data. My question is rather about updating the believes of the Network...similar to method '_update_belief' in 'DBNInference' which is only applicable to DBN networks. Static networks with inference BeliefPropagation have method '_update_beliefs' but it has different application, it is a message passing algorithm to update belief of a cluster using the believes of its neighbors.
My question is if there is a way for a static Network to evolve from the evidence by updating the believes but not the CPDs?

[ankurankan]

@borjasor I am not sure if I understand what you mean by updating the belief but not the CPDs. Could you maybe elaborate a bit on what you are trying to achieve by the update? To me both updating the CPD or updating the belief seem equivalent as the beliefs are simply another data structure derived from the CPDs.

[borjasor]

@ankurankan , as I understand, updating believes is resolving probabilities of all nodes considering the values of those you have evidence of. I do not think this is the same as updating the conditional probabilities between child nodes and parents (CPDs). For instance if you have a Naive BN classifier as root node, getting incomplete evidence of the feature nodes would hardly serve as a good input to update the model's CPDs, as this relate the dependencies between the root class and the features and you never observed the root class in any of those evidences. Also, re-fitting the CPD for every evidence may be costly. I think the question in this thread is how do you keep the influence of the accumulation of evidences in your model. One way, in particular for Naive BN, could be to add new child nodes for each new evidence...so you grow your model as you get new evidence...you do not change the CPDs just increase the leave nodes. Notice that we are talking about Static models, as something like this is what may be implemented on a Dynamic model already. This relates to my other question about implementing weight in the nodes of BayesianNetwork class which is also asked by the author of this thread. Imagine in the previous example that you want to weight down the influence on your root node by the 'old' evidences, you could do that by 'weighting' down the edge of the nodes related to that 'old' evidence. This may not be the best way of doing this 'temporal' evidence influence in a Static model so any feedback is always welcome and as always thank you so much for PGMPY and for your support on the project.

[ankurankan]

@borjasor Thanks for the explanation. The approach that you have described is still not entirely clear to me and I have tried to put down some of the things that I am unable to understand below:

updating believes is resolving probabilities of all nodes considering the values of those you have evidence of. I do not think this is the same as updating the conditional probabilities between child nodes and parents (CPDs).

Assuming that with belief we mean the same thing (the posterior of some variable given some evidence), in my previous comment is that this belief can be (and is usually) computed using the CPDs, and that's why I was considering them to be equivalent.

For instance if you have a Naive BN classifier as root node, getting incomplete evidence of the feature nodes would hardly serve as a good input to update the model's CPDs, as this relate the dependencies between the root class and the features and you never observed the root class in any of those evidences.

I would argue that in this case, no matter how we update the model, we would not add any information between the class and the features because that information doesn't exist in the new data points.

One way, in particular for Naive BN, could be to add new child nodes for each new evidence...so you grow your model as you get new evidence...you do not change the CPDs just increase the leave nodes.

This sould a lot like how we deal with virtual/uncertain evidence but I am not able to understand how this would end up updating the model. Could you give me some intuition behind it or any references? And how would we parameterize these new edges that we would create between the old and new nodes.