Paper: Learning Causal Dynamics Models in Object-Oriented Environments (ICLR-2024)

Reviewer comment (Writing):
The manuscript is hard to follow due to the heavy notations and too much jargon, which could be more simplified.

Author response:
1. In some cases the bold letters (e.g. $\mathbf{S}$) are not distinguishable from the normal letters (e.g. $\mathrm{S}$). Therefore, now a normal letter always carries a subscript (e.g., $\mathrm{A}_i, \mathrm{S}_i$, $\mathrm{S}_j$) so they can be well distinguished.
2. The notation $\mathbf{U}$ is no longer used. Instead we will use $(\mathbf{S}, \mathbf{A})$ directly. This way we avoid introducing unfamiliar notations, and $\mathbf{U}$ will not be confused with the letter used in a field $C.U$ or an attribute $O.\mathrm{U}$.
3. We have changed the notation of local class-level causality to $C.U \rightarrow V$, and that of glocal class-level causality to $C_l.U \rightarrow C_k.V$. These notations are simpler and more intuitive.
4. We simplified equations (5-10) in the old version, and now there are only two equations (5-6) in the revised version to express the same meaning. This reduces the reader's workload and the complexity of the notation.

Reviewer comment (Evaluation):
OOFULL, which is the ablation of OOCDM without causal discovery, uses a fully-connected bipartite graph. In other words, it only leverages the (A) *structural information* (objects belonging to the same class share the same dynamics), without the (B) *causal relationship* between variables. As shown in Table 3-4, OOFULL outperforms other CDMs. Given that CDMs work fairly well in causal discovery (as shown in Table 1), this implies that **(A) structural information (how variables are grouped with objects and classes) is the major contribution** to the performance gain of OOCDM. This poses additional questions, e.g., why and how does OOFULL (which is non-causal) generalize better than CDMs? It seems the assumptions are too strong (i.e., more important than causality). Also, how does the accurate understanding of causality lead to the improvement of OOCDM compared to OOFULL?

Author response:
It's true that OOFULL outperforms CDMs. There are 2 main factors that lead to overfitting:
1. Making predictions from **spurious correlations**. CDMs are able to ameliorate this factor by learning the causal structure.
2. Even with oracle causal discovery, overfitting can still occur within the structural equations because they are still learned from a **limited amount of data representing the entire space**. CDMs have no capacity to solve this problem, which **explains why CDMs fail on o.o.d. data**. For example, CDL-A performs better than CDL at causal discovery, but generalizes worse than CDL. The reason is that the attention in CDL-A is much stronger than the pooling mechanism in CDL, leading to more overfitting within the structural equations.

One way to reduce the overfitting from the second reason is to increase the number of samples. OOCDM and OOFULL are able to do this because each instance of the class $C$ is treated as a sample for learning the predictor $f_{C.V}$. Thus, the sample size increases significantly. Another reason for OOFULL to generalize better is that causation symmetry limits the VC dimension of the model, which reduces the chance of overfitting.

Based on the above analysis, the generalization ability of OOCDM benefits from 3 sources: causal structure, causation symmetry, and increased sample size. OOFULL benefits from causation symmetry and increased sample size, but not from causal structure. CDMs, on the other hand, only benefits from causal structures. As a result, we observe that the performance is OOCDM > OOFULL > CDMs.

Reviewer comment (Evaluation):
CDMs work fairly well in causal discovery (Table 1), but they fail on o.o.d data, as shown in Table 3. This is contrary to the findings of prior works (CDL, GRADER) and requires explanations.

Author response:
Even with oracle causal discovery, overfitting can still occur within the structural equations because they are still learned from a **limited amount of data representing the entire space**. CDMs have no capacity to solve this problem, which **explains why CDMs fail on o.o.d. data**. For example, CDL-A performs better than CDL at causal discovery, but generalizes worse than CDL. The reason is that the attention in CDL-A is much stronger than the pooling mechanism in CDL, leading to more overfitting within the structural equations.

Reviewer comment (Experiments):
In the evaluation of model-based RL (Table 4), the dynamics models are trained using only offline data. However, prior work (GRADER) suggests that it achieves better performance (in terms of both causal discovery and RL) when using online data. A justification for this choice is needed.

Author response:
GRADER indeed suggests using online learning to improve its performance. In this paper, we do not specify how OOCDM should be used, and online learning is absolutely acceptable. We experimented with offline data because it is the best way to demonstrate the generalization performance of the model. If OOCDM can handle this challenging case, we have no doubt that it can perform better when online data is available. Moreover, GRADER's theory requires that we repeatedly perform causal discovery with new data. Considering that the causal discovery of GRADER can take hours, we doubt that it is practical to make comparisons with CDM baselines.

Reviewer comment (Evaluation):
How is accuracy in Table 1 evaluated?

Author response:
The causal graph accuracy is measured by SHD. We will include this in the main paper.

Reviewer comment (Evaluation):
Table 1 shows that GRADER performs worse in causal discovery compared to other methods. This is counter-intuitive given that GRADER uses explicit conditional independence tests, unlike others.

Author response:
GRADER employs Fast CIT (FCIT), for which we use the official FCIT package from github. To test whether $X$ and $Y$ are independent conditional on $Z$, the idea of FCIT is to train 2 decision trees -- one predicting $Y$ using only $Z$, and the other predicting $Y$ using both $X$ and $Z$. Then a t-test is performed based on the mean square errors of the two decision trees. To ensure that the test is "fast", the time to train these trees is quite limited, so the precision of the trees is worse than the neural networks used in CDL and OOCDM. It is the low precision of these decision trees that compromises the performance of causal discovery in GRADER.

Reviewer comment (Writing):
There is an issue with having two separate notations in Def. 2. For example, $C_k\left[U \rightarrow V^{\prime}\right]$ can be written as $C_k\left[C_k \cdot U \rightarrow V^{\prime}\right]$. It would be much easier to follow the paper with simple and consistent notations (maybe just write as $C_l \cdot U \rightarrow C_k \cdot V'$?).

Author response:
The expression $C_k[C_k.U \rightarrow V]$ is different from $C_k[U \rightarrow V]$. Assume that $C_k$ is $product$, where $U$ is $price$, and $V$ is $sell$. Then, $Product[Price \rightarrow Sell]$ means that the sell of each product is affected by its own price. $Product[Product.Price \rightarrow Sell]$ means that the sell of each product is influenced by the price of all other products (which is true in a competitive market). Note that $k = l$ is not forbidden in Definition 2. That's why we have to distinguish between notations for local and global casalities. Maybe $C.(U \rightarrow V)$ and $C_k.U \rightarrow C_l.V$ is better here?

Reviewer comment (Writing):
In eq. 4, $O_p, O_q$ should be $O_x, O_y$.

Author response:
5. The subscripts of objects in Eq. 4 (now Eq. 3) are now corrected.

Reviewer comment (Writing):
The notation $f(\cdot\mid \mathbf{O}; \mathbf{U}_{-O}; \mathcal{G})$ in Eq. 5 (as well as Eq. 8-10) is confusing. Isn’t it basically the same as $f(\cdot\mid \mathbf{U}; \mathcal{G})$? Also, notations in Eq. 8-10 are not consistent with Eq. 5.

Author response:
4. We simplified equations (5-10) in the old version, and now there are only two equations (5-6) in the revised version to express the same meaning. This reduces the reader's workload and the complexity of the notation.
7. We now write a field predictor using the form $f_{C.V}(O.\mathrm{V}'|\mathbf{S},\mathbf{A};\mathcal{G})$.

Reviewer comment (Theory):
In Sec 4.3, it says “$\mathcal{G}_1$ is the full OOCG”. To my understanding, $\mathcal{G}_1$ is a fully-connected bipartite graph and is not OOCG.

Author response:
A fully-connected bipartite graph satisfies the definition of an OOCG, where all causality expressions hold.

Reviewer comment (Presentation):
In Table 7, description of $O.\mathbf{S}$ should be "action → state".

Author response:
6. in Table 7, "action" is corrected to "state" for the meaning of $O.\mathbf{S}$.

Reviewer comment (Presentation):
The ground-truth causal graph provided in the appendix is hard to understand; including the actual graph or adjacency matrix would be better.

Author response:
9. We have visualized the adjacency matrices of the ground truth OOCGs in Appendix G and the discovered OOCGs in Appendix H. These figures are intended to be more direct and understandable than the old presentation of OOCGs.

Reviewer comment (Writing):
While the work is quite interesting and very relevant to the field, the writing itself could use some work. The notation is not clearly specified over the paper and the distinction between bold and normal capital letters is hard to understand (eg. for U). For example, in Section 3.1, what does the random variable S represent? What happens if the transitions are time-dependent?

Author response:
Regarding notations, you can find a list of all notations in Appendix A. Combining the notations for object-oriented representation and causal inference was more complicated than we thought, so there may be some confusion. We use recommended notations in the ICLR template, but it's true that bold and normal letters are sometimes indistinguishable. We will try to find a way. How about
$\vec{\textrm{S}}, O.\vec{\textrm{S}}$?

Currently we are considering the FMDP setting. If the transition depends on time, just make "time" a variable (which the predictor is manually given as $t' = t + 1$) in the FMDP.

1. In some cases the bold letters (e.g. $\mathbf{S}$) are not distinguishable from the normal letters (e.g. $\mathrm{S}$). Therefore, now a normal letter always carries a subscript (e.g., $\mathrm{A}_i, \mathrm{S}_i$, $\mathrm{S}_j$) so they can be well distinguished.
2. The notation $\mathbf{U}$ is no longer used. Instead we will use $(\mathbf{S}, \mathbf{A})$ directly. In this way we avoid introducing unfamiliar notations, and $\mathbf{U}$ will not be confused with the letter used in a field $C.U$ or an attribute $O.\mathrm{U}$.

Reviewer comment (Writing):
The difference between $\mathcal{F}$ and $\mathcal{F}_s$ is not explained at all, and just directly used in Definition 2.

Author response:
$\mathcal{F}$ and $\mathcal{F}_s$ are explained in Section 3.2:
- "$C_k$ specifies a set $\mathcal{F}[C_k]$ of fields that determine the attributes of $O_i$ as well as other instances of $C_k$."
- We will use $\mathcal{F}_s[C_k]$ to denote the set of state fields of $C_k$ corresponding to state attributes. 

Since Definition 2. is a bit far from Section 3.2, it's hard for the reader to catch up. We will add a sentence after Definition 2 about where to find the meaning of $\mathcal{F}$ and $\mathcal{F}_s$.

3. We have moved the explanation of $\mathcal{F}_s$ into Definition 2 where the notation is used.

Reviewer comment (Theory):
The authors should also take some space to explain the fundamentals of CIT / CMI methodology, and can then point to the Appendix for further clarity. However, without some background on CIT / CMI as well as how gradient based learning can be used to learn the graph structure (Equation 12), it is hard to follow the paper since graphs are discrete objects and gradient ascent based procedures only work on continuous spaces.

Author response:
We accept your suggestion to briefly explain CIT in the paper. Equation (12) is used to train the predictors in the model instead of learning the causal graph. Then the predictors are used to perform causal discovery through equations (6, 7, 8, 9, 10). Thus, the learning of the causal graph itself is not directly based on gradients. The pseudocode in Appendices E.2. and E.3. further clarifies this process.

4. We have added a brief explanation of the Conditional Independence Test (CIT) in Section 3.1. Meanwhile, more information about CIT and how CMI is used for CIT is added in Appendix B.4.

Reviewer comment (Writing):
For the most part, my main qualms about the work are regarding the clarity and completeness of writing in the main draft. While the Appendix does contain a lot of details, I felt that there was some key information missing in the main draft and the preliminary section which makes the paper fairly dense and hard to read. There are also a few related works that the authors are missing. I think clarifications on the math and making the notation and related work clearer in the main draft would go a long way, and I would be happy to increase my score if the changes were made.

Author response:
First of all, we understand your concern about the readability of the paper. We will try our best to improve this in the revised version.

8. We have added the recommended papers into related works.

Reviewer comment (Writing):
What does it mean that the state variables transit independently? It would be nice if the authors could write it down in math, as it is not immediately clear for people who do not work on RL or the FMDP setup. I understand it is in the appendix but it would be nice to spell it once in the main text.

Author response:
We accept your suggestion about this question and will make the change in the revision.

6. We have added the mathematical expression of "independent transition" in Theorem 1.

Reviewer comment (Theory):
How does the theorem imply that testing every edge requires O(n) complexity?

Author response:
Consider testing an independence relation between $X$ and $Y$, conditional on $Z$.
Typically, CIT methods learn two prediction models $\hat{Y} = f(Z)$ and $\hat{Y} = g(X, Z)$ -- that is, we try to predict $Y$ with and without $X$. If the independence holds, $Y$ does not carry information from $X$, so the two prediction models should yield identical results; by comparing the difference between the two prediction models, we can determine whether independence holds. The computational complexity of $f$ and $g$ is bounded by the size of their inputs, which are $O(n)$ in equation (2). Therefore, checking each edge costs at least $O(n)$.

Reviewer comment (Theory):
In Equation 3, why does the distribution not depend on $\mathbf{O}_{i+2}$ and so on? Further, what is the benefit of using semicolon in describing the conditioning, and why is $O_i.(\mathbf{S}’)$ dependent on $\mathbf{O}_i$ and not $\mathbf{O}_i.\mathbf{S}$?

Author response:
(a) Sorry for the typo. An ellipsis is missing after $O_{i+1}$. We will correct this in the revision.

(b) We use the semicolon in equation (3) to emphasize the order of the condition variables to which function $p_{C}$ may be sensitive. For example, assuming that $O_1$ and $O_2$ are objects of the same class $C$, based on (3) we have

$$p(O_1.\textrm{S}' | \textrm{U}) = p_{C}(O_1.\textrm{S}' | \textrm{O}_1; \textrm{O}_2, \textrm{O}_3, \cdots, \textrm{O}_N)$$

$$p(O_2.\textrm{S}' | \textrm{U}) = p_{C}(O_2.\textrm{S}' | \textrm{O}_2; \textrm{O}_1, \textrm{O}_3, \cdots, \textrm{O}_N)$$

As we can see, the order of the condition variables in $p_C$ is different in the two equations. Thus, the way $p_C$ handles $\textrm{O}_1$ for $O_1.\textrm{S}'$ is the same as the way it handles $\textrm{O}_2$ for $O_2.\textrm{S}'$. The semicolon can emphasize this positional meaning of condition variables, so it is clear that $\textrm{O}_i$ always takes the first position. Otherwise we would have $p(O_1.\textrm{S}' | \textrm{U}) = p(O_2.\textrm{S}' | \textrm{U})$, which is incorrect.

7. We have added the missing ellipsis in Eq. 3 (which is Eq. 2 in the revised version).

Reviewer comment (Theory):
Dynamics bayesian networks are rather limited rendering them unsuitable to model causal mechanisms. Especially when there is a need for cross layer inference, i.e., identifying the effect of an intervention from observational data. For more information, please see "On Pearl’s hierarchy and the foundations of causal inference." in Probabilistic and Causal Inference: the works of Judea Pearl. In the specific scenario like the one define in this paper, it would be fine (Markovian, no confounders). But still, I would suggest the author use more rigorous causal tools to model the problem.

Author response:
In this paper, we focus on Factored MDPs (FMDPs), so that methods based on FMDPs would benefit from our work. The baselines (CDL, GRADER, TICSA) are all based on the settings of Factored MDP, and their settings also exclude confounders. Thus, we only claim to provide a solution to the current scalability problems of these baselines. With respect to the claim of our paper, we believe that using FMDP does not harm the rigor of this paper. 

We agree that the use of FMDP imposes limitations. As you pointed out, there are no confounders and the transition is strictly Markovian, which is not applicable in some real-world problems. We will add this statement about this weakness in Appendix I. Extending our methods to an environment with non-Markovian dynamics, partial observability, or latent confounders is interesting but also challenging.  In our future work, we will certainly investigate such more challenging problems.

Reviewer comment (Novelty):
In section 3.2, when the authors started to define OOMDP, they claim that "following (a Factored MDP paper), we formulate the task as an Object-Oriented MDP (OOMDP)...". The way of presenting the concept totally ignores a seminal previous work that proposed OOMDP already [1]. Interestingly, the authors also referred to this paper in the related works section but seem to forget it here in the main text.

Author response:
The reason why [1] is missing in Section 3.2 is that the definition of [1] formulates the dynamics through a set of logical rules (so [1] is a special case for our problem). We do not hope to impose this strong restriction on our setting of the problem, so we avoid citing [1] in Section 3.2. Since "OOMDP" seems to be the most relevant way to name the problem, we have also used it in our paper. We will add a brief explanation of this issue in Section 3.2 in the revision.

Reviewer comment (Theory):
In section 4, the core assumption of this paper, "causation symmetry", which assumes that objects from the same class have the same causal effect on other objects, is too strong to be practical. Consider a system where three objects from the same class are linked one by one by springs in a line (obj1 --spring-- obj2 --spring-- obj3). For the causal effect of pulling obj2/obj3 on obj1, they are not interchangeable due to the existence of springs.

Author response:
The problem can be solved by introducing additional attributes in the representation. We can include "identity encoding" in the attributes of objects. For example, we can define $Obj.ID$ fields for these objects. For example
$$ Obj1.\textrm{ID} = 1, Obj2.\textrm{ID}=2, ... $$
Then the objects become interchangeable, so causal symmetry holds. Then these IDs will be well handled by our attention-based network, which can naturally assign high attention weights to connected objects.

Reviewer comment (Experiments):
The proposed method requires manual construction of the OOMDP representation (obj classes, attributes fields, etc.). When there are truly a vast number of classes, this would be a new bottleneck for scaling. This fact, to some extent, hinders the authors' original goal of improving the efficiency of current CDMs learning methods. Similarly, when each object belongs to a distinct class, the proposed method might be even worse due to those detailed object fields.

Author response:
You are right. The key of our method is to share casual structures between objects. But if all objects are from different classes, there is no way to share causal structure. In this case, we have $m$ (the number of fields) equal to $n$ (the number of variables), then the time complexity of causal discovery becomes $O(n^2N)$, where $N$ is the number of objects. In the worst case, we have $N = n$ (each object contains only 1 variable), then the complexity is as bad as for non-object-oriented methods. However, we hope to clarify that our method is not designed to solve such an extreme case, which is against the motivation of our approach.

Reviewer comment (Writing):
When we typically mention local causality, we refer to the case where the causal edges vary, as illustrated in Figure 2 in [1]. In this paper, when the authors mention local causality, it refers more to the causal graph of transitions for individual category objects. I think it is better to give a clarification in the revised version.

Author response:
The suggestion is very useful here.  In fact, In Section 4.1 we write "The local causality describes shared structures within
each object" and used Figure 3(a) to further exlain the concept. We will add a footnote with citation to [1] in the revision to reduce any misunderstanding.

Reviewer comment (Theory):
While the presented work demonstrates a comprehensive approach to object-oriented reinforcement learning, it appears to omit direct consideration of interactions between objects or entities within the framework. Given the prevalence of interactions among objects in real-world reinforcement learning scenarios, particularly in tasks involving object manipulation, this seems to be a significant aspect to address. Could the authors shed light on whether the framework is capable of learning and accounting for these interactions? Insights on how the model might be extended or adapted to incorporate direct interactions among objects would be greatly beneficial, as it would enhance the applicability of the approach to a wider array of real-world scenarios.

Author response:
It is a interesting topic to consider "relational interactions" in object-oriented dynamics. Here we may come up with a few solutions for that concern. 

First of all, our mathod supports an **implicit solution**. We may assign an additional identification attribute called "ID" for each object, then the attention model should be able to capture the relational interaction. High attention weights will be assigned to the objects that take part in the interaction by matching to their IDs. If there are different kinds of relations, we may use multi-head attention in the model. The drawback of this approach is that these relations are implicit in the causal graph.

The second solution is **introducing additional attributes about who the object may be interacting with**. For example, in the starcraft environment, we may add a feild like "Marine.AttackTargetID", which gives the ID of the target object that the marine is attacking in an "attack" relation. A special value for the attribute means that the marine is attacking no one (i.e., not in an attack relation). Then, we probably will have these causations in the causal graph:
$$ Zerg[Marine.AttackPoint \rightarrow Health], Zerg[ID \rightarrow Health], Zerg[Marine.AttackTarget \rightarrow Health]  $$

The third solution is **introducing addition relation classes for each kind of interaction**. The fields of the class are the IDs of participants of the relation. For example, we may define a class $Attack$ for the attack relation, which has fields $Attack.Attacker, Attack.Target$.  Then, we probably will have these causations in the causal graph:
$$ Zerg[Attack.Target  \rightarrow Health], Zerg[ID  \rightarrow Health] $$

Note that in the second and third solutions, the participants of the relations become a state variable in the environment and can be predicted by the model.  Moreover, the network may be specially designed to better handle the $ID$ attributes with relational interactions.

Reviewer comment (Novelty):
The combination seems a bit not nontrivial in a sense that, while the fomulation is a bit complicated but, at a fundamental level, we just generalize causal dynamics learning to an object-oriented version, and apply the idea of conditional independence. Causal dynamics learning or causal discovery is just a transition probability between the two time steps, and we replace probabilities of random variables to represent probabilities among attributes of objects. We refine variables to consider only the relevant ones.

Author response:
This paragraph actually gives a summary of our work -- "generalizing causal dynamics learning to an object-oriented version" is our contribution, and "refining variables to consider only the relevant ones" is our motivation. I am not sure why these statements constitute the weaknesses of our work. The combination seems straightforward, but many issues need to be considered. This paper answers 1) under what condition is the same causal structure shared? 2) Exactly which variables are relevant? 2) what network architecture can be used for inference, and 4) how much does this reduce computational complexity. Meanwhile, we have demonstrated the effectiveness of this combination through experiments.

Reviewer comment (Novelty):
This OO causal graph or causal discovery is not a new concept (see Marc Maier and Prof. David Jensen (UMASS)’s work on relational causal discovery), which is a more general setting not just t-1 and t. Temporal version is also proposed (Marazopoulou et al. Learning the Structure of Causal Models with Relational and Temporal Dependence, UAI 2015). There is no special needs to class-level local/global causality.

Author response:
I believe there is some necessity to use class-level causality in our setting. We focus on learning the causal structure in a **Factored MDP** because there have been a large number of studies using this structure to solve their problems, as mentioned in Section 2.1. The OOMDP is just a special case of the FMDP, so our model can directly serve all methods that work on the FMDP, as long as an object-oriented segmentation of the FMDP's variables is available.  **RCD involves another concept called "relations", which is not modeled in FMDPs or OOMDPs -- these relations may exist, but are implicit in the factorization**. Consider the example of students taking courses (Fig. 2 in [1]), the relation "Take" may be implicitly described by two vectors $Alice.Take = (1, 0)$, $Bob.Take = (1, 1)$ in the FMDP. The OOMDP (FMDP) will only model these relationships as attributes (variables) in the state space, so class-level causality is needed to describe the causal graph when relations are not modeled or implicit (e.g., $Course[Student.Take \rightarrow Difficulty]$).

In addition, the classes and objects in OOMDP have already required a lot of domain knowledge about the environment. If the domain knowledge about relations is also required, the approach would be much more limited. Even a layman can instinctively know how to classify objects, but relations sometimes require experts. Meanwhile, RCD requires to learn a unique model for each type of relation, which is also very expensive, while our solution has a lower complexity.

Reviewer comment (Novelty):
Regarding “Scalability”, do you mean this part “This causality sharing greatly simplifies causal discovery and improves the readability of CGs in large-scale environments.“ in page 4? If so, isn’t this an already existing result in relational causal discovery? Otherwise, where does the claim of scalability come from?

Author response:
Scalability is embodied in the paper in many ways, not just in the sentence you quote. Of course, that sentence is already covered by the RCD papers, so I will add a reference there in the revised version. However, most of the claim about "scalability" is still original, embodied in the following aspects:
1. Part of the scalability comes from the **Causal Symmetry** (Eq. 4), which is not included in RCD. This symmetry allows us to use attention in the model because the input key and value vectors of attention are also **symmetric**. In this way, the model can capture the joint influence of other objects and manage different numbers of objects. In the RCD studies, their regression models do not have this property. As a result, in Fig. 9 of [1], the precision of causal discovery decreases when the number of entities increases from 2 to 3. However, the causal discovery of our model achieves higher precision with more entities.
2. RCD only concludes that the scalability of the causal discovery is improved, but we also examine the scalability of the **prediction performance** of the model. Many RL applications require the model to be accurate in predicting the next state. Table 3 in the main paper shows that OOCDM outperforms other causal models.
3. RCD does not conclude that scalability about **computational cost**. In some applications, such as model-based policy optimization, causal discovery is performed repeatedly in each iteration with new data collected. In large-scale environments, causal discovery can be excessively time-consuming, making the application of causal models intractable. In such applications, computational cost may be the most important aspect of scalability. In Table 2, we show that our object-oriented version of the model greatly reduces computation time.

[1] Marazopoulou et al. Learning the Structure of Causal Models with Relational and Temporal Dependence, UAI 2015