Causal deep learning (CDL) is a new and important research area in the larger field of machine learning. With CDL, researchers aim to structure and encode causal knowledge in the extremely flexible representation space of deep learning models. Doing so will lead to more informed, robust, and general predictions and inference— which is important! However, CDL is still in its infancy. For example, it is not clear how we ought to compare different methods as they are so different in their output, the way they encode causal knowledge, or even how they represent this knowledge.

This is a living paper that categorises methods in causal deep learning beyond Pearl's ladder of causation. We refine the rungs in Pearl's ladder, while also adding a separate dimension that categorises the parametric assumptions of both input and representation, arriving at the map of causal deep learning. Our map covers machine learning disciplines such as supervised learning, reinforcement learning, generative modeling and beyond.

Our paradigm is a tool which helps researchers to: find benchmarks, compare methods, and most importantly: identify research gaps. With this work we aim to structure the avalanche of papers being published on causal deep learning. While papers on the topic are being published daily, our map remains fixed. We open-source our map for others to use as they see fit: perhaps to offer guidance in a related works section, or to better highlight the contribution of their paper.

§ INTRODUCTION

For a long time, philosophers and scientists have been formalising, identifying and quantifying causality in nature, even dating back to 18th century philosopher David Hume [Hume, 1751]. The ability to perform causal reasoning has been recognized as a hallmark of human intelligence [Pearl and Mackenzie, 2018]. It is only expected that causality has found its way as a research topic in artificial intelligence (AI). In fact, we recognise a true explosion of ideas and proposals in machine learning (a sub-field of AI) that build upon ideas from causality.

Causality. Although there exist several different frameworks for causal reasoning as well as some on-going philosophical debate [Lewis, 1974, Lewis, 1979, Pearl, 2009, Rebane and Pearl, 2013, Simon and Rescher, 1966, Collingwood and Collingwood, 2001, Gasking, 1955, Menzies and Price, 1993, Von Wright, 2004, Woodward, 2005, Salmon, 1984, Williamson, 2011], the most widely adopted notion of causality in computer science is given by the structural causal model (SCM), introduced in the early 20th century [Wright, 1920] and now championed by Judea Pearl. These SCMs are the main topic of study in causality. They are used for identification, problem formulation, and reasoning.

The practice of categorising methods according to causal knowledge is not new. In fact, Pearl has introduced the widely adopted “ladder of causation” [Pearl and Mackenzie, 2018, Bareinboim et al., 2022] which is illustrated in <ref> (on the left).

remember picture,
example/.style=circle, fill=red, inner sep=.7mm,
grid/.style=gray, dashed,

[inner sep=0, anchor=north west] (ladder) at (0, 0)

[inner sep=0, align=center] at ($(ladder) + (0, 3.3)$) Ladder of causation [Pearl and Mackenzie, 2018];

[inner sep=0, align=center] at ($(ladder) + (9.8, 3.3)$) Map of CDL;
[inner sep=0, align=center, text width=4.5cm] at ($(ladder) + (9.8, 2.2)$) We refine the ladder by including a scale to categorise model parameters and structure categories.;
[inner sep=0, align=center] at ($(ladder) + (.05, 2.5)$) counterfactual;
(cf) at ($(ladder) + (2.5, 2.2)$);
[inner sep=0, align=center] at ($(ladder) + (0, .58)$) interventions;
(iv) at ($(ladder) + (2.5, .2)$);
[inner sep=0, align=center] at ($(ladder) + (0, -1.65)$) association;
(as) at ($(ladder) + (2.5, -2.1)$);

[example, label=[Vaswani et al., 2017]] (transf) at ($(as) + (-.1, .3)$) ;
[example, label=[Williams and Rasmussen, 2006]] (rf) at ($(as) + (.3, -.2)$) ;
[example, label=[Montgomery et al., 2021]] (lr) at ($(as) + (-.5, -.1)$) ;

[circle, very thick, draw=purple, inner sep=1.2, fill=white,  label=above:all are categorised the same!] (note) at ($(as) + (2, 2)$) ;
[->, thick, purple] (note) to[out=270, in=0] ($(as) + (.7, .1)$);

(input_knowledge_A) at (9.5,-4.5) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);

(input_knowledge_U) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
(input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;
at ($(input_knowledge_U) + (-.3, 0)$) 90structure;
at ($(input_knowledge_A) + (2, -.8)$) parameters;

(input_param_NO) at (10,-5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 3)$);
(input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 3)$);
(input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 3)$);
(input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

[example, label=[Williams and Rasmussen, 2006]] at ($(input_knowledge_A) + (1.5, -.2)$) ;
[example, label=[Vaswani et al., 2017]] at ($(input_knowledge_A) + (.5, -.2)$) ;
[example, label=[Montgomery et al., 2021]] at ($(input_knowledge_A) + (2.5, -.2)$) ;

[purple, thick, ->] ($(as) + (.4, -.4)$) to[out=-35, in=225] node[midway, text width=2.5cm, fill=white, align=center] the map refines categorisation ($(input_knowledge_A) + (.5, -.8)$);

Refining the ladder of causation. The ladder (left) depicts different levels of causal knowledge. The higher one climbs, the more knowledge one needs. However, the ladder does not differentiate between (at the extreme) non-parametric models or highly parametric models. Furthermore, we find there are more structures to be taken into account beyond causal structures. Details on the axes are provided in <ref>.

Deep learning. Topics such as identification and reasoning are much less studied in deep learning [Pearl, 2019]. Instead, the focus on deep learning is a much more pragmatic one. Deep learning research is concerned with increasing accuracy [Hestness et al., 2019, Cho et al., 2015, Litjens et al., 2016, Krizhevsky et al., 2017, Deng et al., 2009, Russakovsky et al., 2015, Berrevoets et al., 2021], improving quality of synthetic data [Nikolenko, 2021, Rombach et al., 2022, Kobyzev et al., 2020, van Breugel et al., 2021], or dealing with an increasing amount of parameters [Hunter et al., 2012, Bebis and Georgiopoulos, 1994, Mostafa and Wang, 2019]. These advances are completely ignored by Pearl's ladder (as it only focuses on the causal knowledge embedded in the models). This fact is illustrated by including some examples of models that are parameterised very differently (from linear regression [Montgomery et al., 2021] to transformer networks [Vaswani et al., 2017].

Causal deep learning (CDL). Clearly both causality and deep learning have their own respective merits. One emphasises research on mitigating bias or providing rigorous estimates, whereas the other is much more pragmatic and focuses on empirical results. However, recently, researchers start to pay much more attention on the interaction between each field.

Given the two basic pillars of causal deep learning: (i) causality, and (ii) deep learning, we propose to categorise causal deep learning methods according to these two pillars. While it is clear that each field can aid the other, the focus of each pillar is actually conflicting, e.g., typical work in causality is very good at leveraging structure, but not very good at non-parametric estimation; the reverse is true for deep learning. We propose to measure exactly how each method in this new and emerging field compares to one another by considering how they match up in each of CDL's pillars. To do this, we introduce a map of causal deep learning.

To illustrate its necessity, we have included a rudimentary version of the map of CDL in <ref>. While Pearl's ladder is not able to differentiate between transformer networks and linear regression, our map is. Naturally, we discuss in much more detail how we arrive at our map in <ref>. However, <ref> shows (on the right) that our map can indeed differentiate between these wildly different examples.

A living paper. We will constantly update this paper to incorporate new developments, accommodating the growth and many changes this field undergoes going forward. However, we believe we have constructed our map to stand the test of time.

§ THE STRUCTURAL AND PARAMETRIC SCALE

We propose a map to organise past and future research in CDL.

Our map helps us to understand and categorise the many differences and similarities between models in CDL, but also to understand how to situate CDL (and these models) in the wider field of machine learning.

Given the increasing amount of new ideas and proposals in CDL, we believe this to be a necessary exercise.

Causal deep learning refines machine learning by leveraging a different set of assumptions and inductive biases. As these are vital to CDL, we build our map around their classification. Specifically, a these assumptions and biases are defined by two ingredients: (i) the structure linking individual variables, and (ii) the functions that model these links.

As such, the map of causal deep learning operates under two main axes: (i) the structural scale concerning the links between variables, described in <ref>; and (ii) the parametric scale concerning the shape of the functions that model links between variables, described in <ref>.

Our two scales form the basis of the map of causal deep learning, which we introduce in detail in <ref>.

dot/.style=circle, fill=black, draw=black,  minimum size=2mm, inner sep=0,

[inner sep=0] (start) at (0, 0) ;
[inner sep=0] (end) at (8, 0) ;

[dot, inner sep=0] (blob) at (start) ;
[anchor=south, inner sep=0] at ($(start) - (0, .5)$) unknown;
[shift=($(blob) + (0,.5)$)]
[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

(S) – (C);
(C) – (D);
(D) to [out=135, in=45] (S);

[dot, inner sep=0] (directed) at ($(start)!.5!(end)$) ;
[anchor=south, inner sep=0] at ($(start)!.5!(end) - (0, .565)$) plausible;
[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[->, densely dotted] (C) to [in=45, out=135] (S);
[->, densely dotted] (C) to [out=45, in=135] (D);

[->] (S) – (C);
[->] (C) – (D);

[->, densely dashed] (D) to [out=225, in=315] (C);
[->, densely dashed] (C) to [out=225, in=315] (S);

[dot, inner sep=0] (causal) at (end) ;
[anchor=south, inner sep=0] at ($(end) - (0, .5)$) causal;
[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[->] (S) – (C);
[->] (C) – (D);

[blue] at ($(start) + (0, 2.25)$) little structure;
[blue] at ($(end) + (0, 2.25)$) lots of structure;

[very thick] (start) – (end);

[thick, blue, latex-latex, rounded corners=3mm] ($(start)+(0, 1.15)$) – ($(start) + (0, 1.65)$) – ($(end) + (0, 1.65)$) – ($(end) + (0,1.15)$);

The structural scale. A first axis on the map of causal deep learning is the structural scale which categorises different structure types. The two extremes are non-informative structures, or a complete causal graph. Note that the structural scale makes no parametric assumptions on these structures (parametric assumptions are the focus of the parametric scale in <ref>).

§.§ The structural scale

Crucial to causal deep learning is the ability to leverage knowledge about the relationships between variables.

Depicted as graphs, we can place these relations on a scale from less detailed to more detailed – this gives the structural scale, which is central to our map of causal deep learning.

<ref> depicts the structural scale, which ranges from less structure, to lots of structure. The structural scale governs information about the statistical or causal relationship in the environment of interest. Essentially, it quantifies how much we know, expressed in graphical structures. Below, we discuss each level  using an illustrative example of three variables: smoking, denoted as $S$; cancer, denoted as $C$; and death, denoted as $D$.

Level 1 – no structure. At the lowest end of our scale we have structures that exhibit zero knowledge. These structures connect each variable with each other. An example of such a structure is denoted as,

\begin{equation} \label{eq:blob}
\begin{tikzpicture}[
\node[inner sep=1] (S) at (-.8, 0) {$S$};
\node[inner sep=1] (C) at (0, 0) {$C$};
\node[inner sep=1] (D) at (.8, 0) {$D$};

\draw (S) -- (C);
\draw (C) -- (D);
\draw (D) to [out=135, in=45] (S);

\node at (4, 0) {\textcolor{purple}{\bf (unknown).}};
\end{tikzpicture}
\end{equation}

While technically a structure, we have no idea about the potential relationships these variables have with respect to each other. Having a fully connected structure such as in <ref> means that we assume potential dependence between each variable. Assuming a fully connected structure is not a strict assumption. In our example above, the structure in <ref> basically states that “smoking, cancer and death” are possibly related, which is a very general statement indeed.

That is because relatedness is a flexible term. While having an edge may appear to be a strict statement, the edge does not express the level at which two variables are related. In fact, the absence of an edge is a much stronger assumption which we discuss next.

Level 2 – plausibly causal structures. Let us assume now that we know a little more: cancer is the reason why smoking is related to death. Statistically, we can express this assumption as $S \independent D | C$. In Level 2, we assume statistical independence. Independence is not directly the same as assuming some structural information, however, it can be expressed as such.

The easiest thing we can do to reflect $S \independent D | C$ is to explicitly by remove the edge [
[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (D) at (.8, 0) $D$;

(D) to [out=135, in=45] (S);
from <ref> as we have below in <ref>,

\begin{equation} \label{eq:association}
\begin{tikzpicture}[
\node[inner sep=1] (S) at (-.8, 0) {$S$};
\node[inner sep=1] (C) at (0, 0) {$C$};
\node[inner sep=1] (D) at (.8, 0) {$D$};

\draw (S) -- (C) -- (D);

%\node at (4, 0) {\textcolor{purple}{\bf (associative).}};
\end{tikzpicture}.
\end{equation}

Crucially, however, there are more structures that reflect $S \independent D | C$. Consider the three structures below,

[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[->] (S) – (C);
[->] (C) – (D);

[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[<-] (S) – (C);
[->] (C) – (D);

[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[<-] (S) – (C);
[<-] (C) – (D);

which all model the same independencies.

For the sake of our discussion, let us assume $S \independent D | C$ is correct[If cancer renders smoking and death independent, we imply that cancer is the only path from smoking to death, which is known to be false [Carter et al., 2015]. For example, smoking may result in chronic obstructive pulmonary disease (COPD) or ischemic heart disease, which can also lead to premature death. However, for the purpose of illustration, we assume it is true.]. As (in)dependence is a statement of statistical association, we cannot assume that the structures based on it are causal in nature. For example, [
[inner sep=1] (S) at (-.8, 0) $S$;
[inner sep=1] (C) at (0, 0) $C$;
[inner sep=1] (D) at (.8, 0) $D$;

[<-] (S) – (C);
[<-] (C) – (D);
, implies that dying impacts whether or not the deceased is a smoker, which cannot be true.

The type of structure of interest in Level 2, are the probabilistic graphical models (PGMs) [Koller and Friedman, 2009]. These include structures such as directed acyclic graphs (DAGs), undirected graphs, or even factor graphs. Depending on the set of independence statements one wishes to assume, one may express them as a certain type of PGM.

For example, if one wishes to assume $S \independent D$ while also assuming $S \not\independent D | C$, we best use a DAG:

\begin{equation} \label{eq:collider}
\begin{tikzpicture}
\node[inner sep=1] (S) at (-.8, 0) {$S$};
\node[inner sep=1] (C) at (0, 0) {$C$};
\node[inner sep=1] (D) at (.8, 0) {$D$};

\draw[->] (S) -- (C);
\draw[<-] (C) -- (D);
\end{tikzpicture},
\end{equation}

which is often called a “collider” structure. This collider structure (and more importantly the (in)dependence statements it implies) can only be modeled with a DAG.

Being able to model independence is a clear step up from Level 1, where we assumed nothing at all. While independence is a statement of statistical association (i.e. it is bidirectional and not causal), they do pose constraints for a later causal model. As we can check (in)dependence in data, a recovered causal model should respect (or even explain) these (in)dependence statements. Hence, the above structures are plausibly causal.

In level 2 we have no consensus on one graph in particular, only about dependence and independence (predominately statistical concepts). For the purpose of illustrating Level 2 on our structural scale in <ref> above, we denote these plausible structures as,

\begin{equation} \label{eq:mec}
\begin{aligned}
\begin{tikzpicture}[
\node[inner sep=1] (S) at (-.8, 0) {$S$};
\node[inner sep=1] (C) at (0, 0) {$C$};
\node[inner sep=1] (D) at (.8, 0) {$D$};

\draw[->, densely dotted] (C) to [in=45, out=135] (S);
\draw[->, densely dotted] (C) to [out=45, in=135] (D);

\draw[->] (S) -- (C);
\draw[->] (C) -- (D);

\draw[->, densely dashed] (D) to [out=225, in=315] (C);
\draw[->, densely dashed] (C) to [out=225, in=315] (S);

\node at (4, 0) {\textcolor{purple}{\bf (plausible).}};
\end{tikzpicture}
\end{aligned}
\end{equation}

where we combined all possible DAGs that respect, $S \independent D | C$ [Sun et al., 2006]. Applying the rules of d-separation [Verma and Pearl, 1990].

While Level 2 includes all types of PGMs, we chose to illustrate Level 2 using DAGs only, as DAGs are the structure of choice when modelling causality [Pearl, 2009]. In <ref> all of the structures are DAGs, but only one of them is causal (likely to be the first one).

Level 3 – causal structure. That leaves assuming the exact causal structure as opposed to the many plausible causal structures in Level 2. With <ref> we say that smoking causes cancer which causes death. Such knowledge translates into the directed structure,

\begin{equation} \label{eq:causation}
\begin{tikzpicture}[
\node[inner sep=1] (S) at (-.8, 0) {$S$};
\node[inner sep=1] (C) at (0, 0) {$C$};
\node[inner sep=1] (D) at (.8, 0) {$D$};

\draw[->] (S) -- (C);
\draw[->] (C) -- (D);

\node at (4, 0) {\textcolor{purple}{\bf (causal).}};
\end{tikzpicture}
\end{equation}

Which was indeed one of the plausible DAGs in Level 2 (<ref>).

Comparing <ref> with <ref> may lead to believe there is little difference between either end of the structural scale– nothing could be further from the truth [Pearl and Mackenzie, 2018, Bareinboim et al., 2022]! Rather, the step from association to causation is very large and is a central argument in causality. So large in fact that we recognise several intermediary structures.

An important realisation is that each level of information further specifies the environment, i.e. with information, we restrict possible interpretations and data-distributions. For example, from <ref> we expect $S$ to change if $C$ is changed as both variables are associated with each other. However, <ref> tells us this is not necessarily the case: patients do not automatically start smoking when diagnosed with cancer. However, the reverse is true; when a cancer-patient stops smoking they have a higher chance of remission [Sheikh et al., 2021].

“Rung 1.5” Pearl's ladder of causation [Pearl and Mackenzie, 2018, Bareinboim et al., 2022] ranks structures in a similar way as we do, i.e., increasing a model's causal knowledge will yield a higher place upon his ladder. Like Pearl, we have three different levels in our scale. However, they do not correspond one-to-one.

In particular, we find that our Level 2 is not well represented in Pearl's ladder of causation[Similarly, his counterfactual rung is not represented in our structural scale.]. Our reasoning is that our Level 2 does encode some prior knowledge into a model, which is more than encoding no prior knowledge at all. Yet, both would be categorised under Pearls first rung. Of course, we recognise that the models categorised under Level 2 have no embedded causal knowledge. While Level 2 does not reach the level of a rung 2 model (but Level 3 does), we consider a Level 2 model to correspond with a hypothetical “rung 1.5”.

§.§ The parametric scale

dot/.style=circle, fill=black, draw=black,  minimum size=2mm, inner sep=0,

[dot, label=below:non-param.] (0moment) at (0, 0) ;
[shift=($(0moment) + (0,.5)$)]
[inner sep=1] at (0, 0) $f(\mathbf{X}, \mathbf{U}_\mathbf{X})$;

[dot, label=below:fully known] (multmoment) at (8, 0) ;
[shift=($(multmoment) + (0,.5)$)]
[inner sep=1] at (0, 0) $f^*(\mathbf{X}, \mathbf{U}_\mathbf{X})$;

[dot, label=below:Noise models] (1moment) at ($(0moment)!.333!(multmoment)$) ;
[shift=($(0moment)!.333!(multmoment) + (0,.5)$)]
[inner sep=1] at (0, 0) $g(\mathbf{X}) +  \mathbf{U}_\mathbf{X}$;

[dot, label=below:fully param.] (2moment) at ($(0moment)!.666!(multmoment)$) ;
[shift=($(0moment)!.666!(multmoment) + (0,.5)$)]
[inner sep=1] at (0, 0) $g(\mathbf{X})$;

[very thick] (0moment) – (1moment) – (2moment) – (multmoment);

[DarkGreen] at ($(0moment) + (0, 1.75)$) no assumptions;
[DarkGreen] at ($(multmoment) + (0, 1.75)$) many assumptions;
[thick, DarkGreen, latex-latex, rounded corners=3mm] ($(0moment)+(0, .75)$) – ($(0moment) + (0, 1.25)$) – ($(multmoment) + (0, 1.25)$) – ($(multmoment) + (0,.75)$);

The parametric scale. A second axis in the map of causal deep learning. The parametric scale logs the type of assumptions made on the factors of the assumed distribution or model. The extremes are no assumptions at all (leaving completely non-parametric factors), or a fully known model. The parametric scale further discerns assumptions on the way noise interacts in the system ($\eps$) and functional shape of the system's factorisation.

In <ref> we defined structures governing the (statistical or causal) relationships between variables. Now we turn to the parameterisation of these relationships. Intuitively, the structures depict which variables express an affinity with each other <cit.>. In particular, each structure dictates how a distribution can be factorised as a series of functions. These functions are called factors, which are defined as,

Let $\mathbf{X}$ be a set of random variables. We define a factor $f$ to be a function from $\text{Val}(\mathbf{X}) \to \mathbb{R}$. A factor is nonnegative if all its entries are nonnegative. The set of variables $\mathbf{X}$ is called the scope of the factor and denoted $\text{Scope}[f]$ <cit.>.

As such, the parametric scale— which we introduce in this section —models not if variables interact, but how they interact. For example, a statement such as $p \models (S \independent D | C)$ holds iff we factorise the distribution as $p(S, C, D) = f_1(S, C)f_2(C, D)$ (lacking a factor $f_3(S, D)$). As such, a structure becomes parameterised by associating a set of factors with it.

Note that associating factors do not necessarily correspond to associating functions for each edge, at least in the undirected setting (such as <ref>). Rather, a factor can be generalised by allowing them over arbitrary subsets of variables. As such, in its most general form, we define a factorisation as,

\begin{equation}\label{eq:factor}
p(\mathbf{X}) = \frac{1}{Z} \prod_{i\in[I]} f_i(\mathbf{X}^{(i)}),
\end{equation}

where $Z$ is a normalising constant, and one factor $f_i$ takes a set of variables, $\mathbf{X}^{(i)} \subseteq \mathbf{X}$, as arguments [Koller and Friedman, 2009].

A trivial example of such a factorisation is the decomposition of a joint distribution into conditional distributions: $p(A, B) = f_1(A, B)f_2(B)$ with $f_1(A, B) = p(A | B)$ and $f_2 = p(B)$. With <ref> one can generalise decomposition to accommodate parameterisation of symmetrical relationships as well as directional relationships (which are generally modelled as conditional probability densities).

Notice that in <ref> we iterate over $I$ factors. However, the amount of factors is, at this stage, not yet fully determined. For example, one could have a factorisation which is comprised of the least amount of factors: $p(\mathbf{X}) = f(\mathbf{X})$, or one could have one where we hope to include a factor with only $X^1$ as an argument: $p(\mathbf{X}) = p(X^1)p(X^2|X^1)...p(X^n|X^{n-1}, ..., X^1)$.

Defining a factor, $f_i$ as in <ref>, is non-parametric (we assume nothing about the factors) and agnostic to the structure it models (because there is no implied correspondence between edges and factors). What does change is the arguments that need to go into a factor. Those are determined by the accompanying structure[While not the topic of discussion here, it is this realisation that is often used as an argument in favour of using causal knowledge to increase efficiency by reducing the input required for correct inference (e.g. in [Lee and Bareinboim, 2018, Lee and Bareinboim, 2019, Kyono et al., 2020, van Breugel et al., 2021, Hassanpour and Greiner, 2019]).].

In our example above, having $A \independent B$ would imply that $p(A | B) = p(A)$, which actively alters the variables that need to go into $f_1$. Recall, that Level 1 of the structural scale is not able to model this explicitly– we need at least a Level 2 assumption for this.

Level 1 – non-parametric. As with the structural scale, Level 1 of the parametric scale encompasses the least strict assumption: namely, there exists a factorisation such as <ref>. Beyond that, level 1 assumes no specific functional form of its factorisations, $f_i$.

Of course, as we move up the structural scale, the structures themselves may dictate the purpose of the factorisation. For example, in a directed structure, the set of arguments changes from an arbitrary set $\mathbf{X}^{(i)}$ to the set containing a variable, its parents and noise: $f_X(X, \pa(X), U_X)$. Nevertheless, despite the factor's arguments changing the function remains non-parametric.

Level 2 – noise models. The next level in our parametric scale is to first make an assumption on the composition of the set of random variables, $\mathbf{X}$. In particular, we assume that $\mathbf{X}$ can be separated in noise terms or exogenous variables $\mathbf{U}$ and variables $\mathbf{X}\setminus\mathbf{U}$ where each element in $\mathbf{U}$ corresponds with exactly one element in $\mathbf{X}\setminus\mathbf{U}$ and $|\mathbf{X}| = 2|\mathbf{U}|$.

The above assumption has implications for the factors. Specifically, if a factor takes $X \in \mathbf{X}\setminus\mathbf{U}$ as argument, it will always take $U_X \in \mathbf{U}$ (which is the corresponding noise variable of $X$) as argument also.

Note that the above is only an assumption on the factor arguments and is per our earlier discussion a graphical assumption. As such, currently, Level 2 is no different from level 1 in the parametric scale. However, in Level 2, we make an additional assumption which is a parametric assumption on the factors. For a factor $f_i(\mathbf{X}^{(i)}, \mathbf{U}_{\mathbf{X}^{(i)}})$ we make an assumption on how the noise variables $\mathbf{U}_{\mathbf{X}^{(i)}}$ are incorporated in $f_i$ [Zhang and Hyvarinen, 2012, Shimizu et al., 2011, Hoyer et al., 2008], for example, additive noise:

\begin{equation} \label{eq:add}
f(\mathbf{X}, \mathbf{U}_\mathbf{X}) = g(\mathbf{X}) + \mathbf{U}_\mathbf{X}.
\end{equation}

In short, <ref> assumes we can decompose a factor $f$ into the noise, $\mathbf{U}_\mathbf{X}$, and some (non-parametric) function, $g(\mathbf{X})$. While the way in which $\mathbf{U}_\mathbf{X}$ interacts in $f$ is fixed, $g$ is still non-parametric and therefore only level 2 of this scale. As discussed below, we find many papers in causal deep learning making assumptions of this level.

When performing causal discovery, making an assumption on the noise of a system may aid in causal identification [Peters et al., 2017]. Conceptually, making this type of assumption is another way to exert some outside expert knowledge into the system. In Hoyer et al., 2008 $g$ remains non-linear (through the use of neural networks) but $\mathbf{U}_\mathbf{X}$ is assumed additively independent (as above) resulting in a clear level 2 assumption.

Level 3 – fully parametric. Naturally, the next level is to make a parametric assumption on $g$ in <ref>. These assumptions vary from making linear assumptions, to $n$ times differentiable, to many more types of assumptions on the functional form of $g$ and consequentially $f$. Note that because we make the assumption on $g$ (and not $f$ directly), we automatically assume that $f$ can be decomposed in $g$ and noise, i.e. Level 3 subsumes assumptions from Level 2.

Less parametric assumptions imply a larger model hypothesis class. For example, having linear assumptions allows much less possible factors than a non-linear class of assumptions. In fact, it has been shown that neural networks[In particular with a ReLU activation.] have a connection to non-parametric regression, leading to high performance models [Schmidt-Hieber, 2020].

As such, making a parametric assumption is typically done in favour of easier regression, but at the cost of less general model classes.

Level 4 – fully known factors. Rather than making assumptions on the functional class of the factors, some methods assume full access to a known set of factors which we term $f^*(\mathbf{X}, \mathbf{U}_\mathbf{X})$. This is of course a very strict assumption, resulting in the final level of the parametric scale.

Having defined our two axes, we can now compose the complete map of causal deep learning in <ref> which governs both model input as well as model output.

§ THE MAP OF CAUSAL DEEP LEARNING

Consider some data, $\mathcal{D} \coloneqq \{\mathbf{X}_i : \mathbf{X}_i \in \mathcal{X}, i \in [N]\}$, with $\mathcal{X}$ some space such as $\mathbb{R}^d$. Generally, the goal of deep learning is to represent these data using a model,

\begin{equation} \label{eq:cdl_model}
m: \mathcal{D} \to \mathcal{H},
\end{equation}

with $m$ the model, and $\mathcal{H}$ a suitably defined space of learned representations which depends on the method to learn $m$.
At a later stage, $\mathcal{H}$ is used to perform a task (such as prediction, or data-generation, or decision making). To perform this task accurately, one has to carefully consider: (i) the type of data ($\mathcal{D}$), and (ii) the type of representation ($\mathcal{H}$) upon which we base the model's output.

The same holds for models in causal deep learning. The difference, however, lays in the types of assumptions and restrictions we pose on (i) the data, and (ii) the representation. Naturally, despite being classified under the umbrella term causal deep learning, there are many differences in how these restrictions manifest. As such, the map of causal deep learning maps (i) the data, and (ii) the learnt representation.

Note that in many cases the representation is the same as the model output. An example of this are causal discovery methods where the aim is to structure the input data as a causal graph. This structure is of course a “representation”. Specifically, a causal discovery method will transform a dataset into a graph: $m: \mathcal{D} \to \mathcal{G}$. In the latter case, we have that $\mathcal{G} = \mathcal{H}$, and $\mathcal{H}$ and the output are the same, corresponding with <ref>.

grid/.style=gray, dashed,
annotation/.style=very thick, red, opacity=.6,
dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
route/.style=very thick, draw opacity=.5,

[label=left:Unknown (U)] (input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);

[label=left:Plausible (P)] (input_knowledge_U) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
[label=left:Causal (C)] (input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

[label=below:(NP)] (input_param_NO) at (.5,-.5) ;
[rotate=-90, anchor=west] at (.5, -1.3) Non-param.;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 3)$);
[label=below:(NM)] (input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_NO) + (1, -.8)$) Noise Models;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 3)$);
[label=below:(Pa.)] (input_param_2) at ($(input_param_1) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_1) + (1, -.8)$) Param.;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 3)$);
[label=below:(FK)] (input_param_M) at ($(input_param_2) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_2) + (1, -.8)$) Fully known;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

(input_title) at ($(input_param_NO)!.5!(input_param_M) + (0, 3.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (1.5, 3.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (1.5, 1.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (1.5, .5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (1.5, -1.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

[label=left:U] (repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);

[label=left:P] (repr_knowledge_U) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
[label=left:C] (repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

[label=below:NP] (repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 3)$);
[label=below:NM] (repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 3)$);
[label=below:Pa.] (repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 3)$);
[label=below:FK] (repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

(repr_title) at ($(repr_param_NO)!.5!(repr_param_M) + (0, 3.5)$) Representation;

[annotation] ($(input_title) - (.55, .2)$) – ($(input_title) + (.55, -.2)$);
[->, annotation] ($(input_title) - (0, .2)$) to[out=270, in=0] ($(input_title) - (3, 0)$) node[annotation, text width=3cm, align=right, anchor=east] properties of the data given to a model;

[annotation] ($(repr_title) - (1.5, .2)$) – ($(repr_title) + (1.5, -.2)$);
[->, annotation] ($(repr_title) - (0, .2)$) to[out=270, in=90] ($(repr_title) + (3.7, -2)$) node[annotation, text width=3cm, align=center, anchor=north] properties of the model's representation or output;

[latex-latex, annotation] ($(repr_knowledge_C) + (-.1, .5)$) – ($(repr_knowledge_C) + (-.7, .5)$) – ($(repr_knowledge_A) + (-.7, -.5)$) – ($(repr_knowledge_A) + (-.1, -.5)$);
[->, annotation] ($(repr_knowledge_C)!.6!(repr_knowledge_A) + (-.7, 0)$) to[out=180, in=90] ($(repr_param_NO) + (-1, -2)$) node[annotation, text width=4cm, align=center, anchor=north] structural scale (<ref>);

[latex-latex, annotation] ($(repr_param_NO) - (.5, .1)$) – ($(repr_param_NO) - (.5, .7)$) – ($(repr_param_M) + (.5, -.7)$) – ($(repr_param_M) + (.5, -.1)$);
[->, annotation] ($(repr_param_NO)!.5!(repr_param_M) + (0,-.7)$) to[out=270, in=180] ($(repr_param_M) + (.5, -1.7)$) node[annotation, text width=3cm, align=left, anchor=west] parametric scale (<ref>);

[gray, route] ($(input_knowledge_A) + (.5, 0) + 1*(1, 0)$) node[dot, gray]  – node[midway, above, rotate=30, gray, opacity=1] Example model ($(time_start) - (0, 1)$) node[dot, gray]  – ($(repr_knowledge_C) + (.5, 0) + 1*(1, 0)$) node[dot, gray] ;

The map of causal deep learning. The map evaluates each model based on the required input and learnt representations. For each, we categorise using both the structural scale (<ref>) and the parametric scale (<ref>). Furthermore, we also discern between models that handle temporal or static data. As an example, we show a fictitious method which assumes no structure but does make an additive noise assumption; operates in the temporal domain; and provides a truly causal representation under the same additive noise assumption. Our map allows easy examination of a method on many properties at once.

Using our scales in <ref>, we provide some categorisation of both objects, leading to the map of causal deep learning, illustrated in <ref>. The map of causal deep learning has three components: Input, Time/static, and Representation. Input and Representation are built from the scales we introduced above. The Time/Static component is a simple binary structure which helps us discern methods that operate on temporal data or static data, respectively.

Input. The input field (leftmost grid in <ref>) categorises the data in terms of assumptions on the data-generating process (DGP). Here, the structural scale measures how much we already know about the DGP in terms of which variables are dependent; whereas the parametric scale measures how these variables are dependent.

Time/Static. We explicitly differentiate between temporal and static models. While evaluated similarly, time may lead to alternative considerations in the causal setting. For example, a typical assumption in the temporal domain is that causes precede effects [Granger, 1969]. While we do not express any opinion on whether or not this makes things harder or easier, we do believe it is important to differentiate in order to properly compare methods. Furthermore, when using our map to search for an appropriate method from a practical point of view, it makes sense to search across static methods for a static problem, and temporal methods for a temporal problem.

Representation. A model's representation is evaluated using the same scales as the Input of the model. This is a deliberate choice as we wish to document how much information a model adds to existing data.

In terms of representation, the structural scale measures what type of structure a model yields; whereas the parametric scale measures how the model is parameterised. Note that the latter is different from assumptions on the DGP as it concerns the maximum capacity of a particular model.

grid/.style=gray, dashed,

[label=left:Unknown (U)] (input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);

[label=left:Plausible (P)] (input_knowledge_U) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
[label=left:Causal (C)] (input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

[label=below:(NP)] (input_param_NO) at (.5,-.5) ;
[rotate=-90, anchor=west] at (.5, -1.3) Non-param.;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 3)$);
[label=below:(NM)] (input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_NO) + (1, -.8)$) Noise Models;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 3)$);
[label=below:(Pa.)] (input_param_2) at ($(input_param_1) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_1) + (1, -.8)$) Param.;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 3)$);
[label=below:(FK)] (input_param_M) at ($(input_param_2) + (1, 0)$) ;
[rotate=-90, anchor=west] at ($(input_param_2) + (1, -.8)$) Fully known;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

(input_title) at ($(input_param_NO)!.5!(input_param_M) + (0, 3.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (2, 3.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (2, 1.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (2, .5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (2, -1.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

[label=left:U] (repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);

[label=left:P] (repr_knowledge_U) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
[label=left:C] (repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

[label=below:NP] (repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 3)$);
[label=below:NM] (repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 3)$);
[label=below:Pa.] (repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 3)$);
[label=below:FK] (repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

(repr_title) at ($(repr_param_NO)!.5!(repr_param_M) + (0, 3.5)$) Representation;

[draw=none, fill=red!40, on layer=back] ($(input_knowledge_A) + (.5, 0)$) .5;

[draw=none, fill=red!25, on layer=back] ($(input_knowledge_A) + (.5, 0) + 1*(1, 0)$) .5;
[draw=none, fill=red!25, on layer=back] ($(input_knowledge_U) + (.5, 0)$) .5;

[draw=none, fill=red!10, on layer=back] ($(input_knowledge_C) + (.5, 0) + 0*(1, 0)$) .5;
[draw=none, fill=red!10, on layer=back] ($(input_knowledge_U) + (.5, 0) + 1*(1, 0)$) .5;
[draw=none, fill=red!10, on layer=back] ($(input_knowledge_A) + (.5, 0) + 2*(1, 0)$) .5;

[draw=none, fill=red!40, on layer=back] ($(repr_knowledge_C) + (.5, 0)$) .5;

[draw=none, fill=red!25, on layer=back] ($(repr_knowledge_C) + (.5, 0) + 1*(1, 0)$) .5;
[draw=none, fill=red!25, on layer=back] ($(repr_knowledge_U) + (.5, 0)$) .5;

[draw=none, fill=red!10, on layer=back] ($(repr_knowledge_C) + (.5, 0) + 2*(1, 0)$) .5;
[draw=none, fill=red!10, on layer=back] ($(repr_knowledge_U) + (.5, 0) + 1*(1, 0)$) .5;
[draw=none, fill=red!10, on layer=back] ($(repr_knowledge_A) + (.5, 0)$) .5;

[->,  very thick] ($(input_knowledge_A) + (-1, -1)$)  node[label=left:Goal]  to[out=0, in=270] ($(input_knowledge_A) + (.5, 0)$);

[->,  very thick] ($(repr_knowledge_C) + (4.5, -1)$)  node[label=right:Goal]  to[out=180, in=270] ($(repr_knowledge_C) + (.5, 0)$);

Goals and direction of the field. We can use the map of causal deep learning to specify the future of our field. Darker shades of red indicate a harder, but more desirable goal. In the case of input, we wish to minimise the required graphical input and made assumptions; with which we hope to achieve a more knowledgeable representation with minimal assumptions.

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
route/.style=very thick, draw opacity=.5,

[inner sep=0] (start) at (0, 0) ;
[inner sep=0] (end) at (0, 5) ;

[inner sep=0] (start_i) at ($(start) + (5, 0)$) ;
[inner sep=0] (end_i) at ($(end) + (5, 0)$) ;

[inner sep=0] (start_r) at ($(start_i) + (3, 0)$) ;
[inner sep=0] (end_r) at ($(end_i) + (3, 0)$) ;

at ($(end) + (0, .75)$) Assumptions;
at ($(end_i) + (0, .75)$) Input;
at ($(end_r) + (0, .75)$) Representation;

[inner sep=0] (start_time) at ($(start)!.33!(start_i) - (0, .5)$) ;
[inner sep=0] (end_time) at ($(end)!.33!(end_i) - (0, .5)$) ;
[inner sep=0] (start_static) at ($(start)!.66!(start_i) + (0, .5)$) ;
[inner sep=0] (end_static) at ($(end)!.66!(end_i) + (0, .5)$) ;

[dashed, black!20] (start) – (start_static) – (start_i) – (start_r);
[dashed, black!20] ($(start)!.66!(end)$) – ($(start_static)!.66!(end_static)$) – ($(start_i)!.66!(end_i)$) – ($(start_r)!.66!(end_r)$);
[dashed, black!20] ($(start)!.33!(end)$) – ($(start_static)!.33!(end_static)$) – ($(start_i)!.33!(end_i)$) – ($(start_r)!.33!(end_r)$);
[dashed, black!20] (end) – (end_static) – (end_i) – (end_r);

[dashed, black!20] (start) – (start_time) – (start_i);
[dashed, black!20] ($(start)!.66!(end)$) – ($(start_time)!.66!(end_time)$) – ($(start_i)!.66!(end_i)$);
[dashed, black!20] ($(start)!.33!(end)$) – ($(start_time)!.33!(end_time)$) – ($(start_i)!.33!(end_i)$);
[dashed, black!20] (end) – (end_time) – (end_i);

[very thick] (start) – (end);
[very thick] (start_i) – (end_i);
[very thick] (start_r) – (end_r);

[blue, thick] (start_time) – (end_time);
[blue, thick] (start_static) – (end_static);

[blue] at ($(start_time) - (0, .3)$) time;
[blue] at ($(start_static) - (0, .3)$) static;

[purple, route] (end) – (end_static) node[dot, purple] – (end_i) – (start_r) – ($(start_r) + (3, -.2)$) node[dot, purple, label=right:Hassanpour and Greiner, 2019] ;

[orange, route] (start) – (start_static) node[dot, orange]  – (start_i) – ($(start_r)!.66!(end_r)$) – ($(end_r)!.33!(start_r) + (3, -.2)$) node[dot, orange, label=right:<cit.>] ;

[green, route] (end) – (end_time) node[dot, green]  – (start_i) – (end_r) – ($(end_r) + (3, 0)$) node[dot, green, label=right:<cit.>] ;

[DarkBlue, route] (end) – (start_time) node[dot, DarkBlue]  – (start_i) – (start_r) – ($(start_r) + (3, .2)$) node[dot, DarkBlue, label=right:<cit.>] ;

[Goldenrod, route] ($(start)!.66!(end)$) – ($(start_time)!.66!(end_time)$) node[Goldenrod, dot]  – ($(start_i)!.66!(end_i)$) – ($(start_r)!.66!(end_r)$) – ($(start_r)!.66!(end_r) + (3, .2)$) node[dot, Goldenrod, label=right:<cit.>] ;

[dot, label=left:Level 1] (association) at (start) ;
[dot, label=left:Level 2] (hybrid) at ($(start)!.33!(end)$) ;
[dot, label=left:Level 3] (directed) at ($(start)!.66!(end)$) ;
[dot, label=left:Level 4] (causal) at (end) ;

[dot] at (start_i) ;
[dot] at ($(start_i)!.66!(end_i)$) ;
[dot] at ($(start_i)!.33!(end_i)$) ;
[dot] at (end_i) ;

[dot] at (start_r) ;
[dot] at ($(start_r)!.66!(end_r)$) ;
[dot] at ($(start_r)!.33!(end_r)$) ;
[dot] at (end_r) ;

The map of causal deep learning.

§ NAVIGATING THE FIELD

Navigating ML with the map.

Location on the map     Supervised     Unsupervised     Semi-Supervised     Reinforcement

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
grid/.style=gray, dashed,
route/.style=very thick, draw opacity=.5,

(input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);
(input_knowledge_M) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_M) + (0, .5)$) – ($(input_knowledge_M) + (4, .5)$);
(input_knowledge_U) at ($(input_knowledge_M) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
(input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

(input_param_NO) at (.5,-.5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 4)$);
(input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 4)$);
(input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 4)$);
(input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

at ($(input_param_NO)!.5!(input_param_M) + (0, 4.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (2, 4.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (2, 2.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (2, 1.5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (2, -.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

(repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);
(repr_knowledge_M) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_M) + (0, .5)$) – ($(repr_knowledge_M) + (4, .5)$);
(repr_knowledge_U) at ($(repr_knowledge_M) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
(repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

(repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 4)$);
(repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 4)$);
(repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 4)$);
(repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

at ($(repr_param_NO)!.5!(repr_param_M) + (0, 4.5)$) Repr.;

[red, route] ($(input_knowledge_A) + (.5, 0) + 0*(1, 0)$)  node[dot, red]  – ($(static_start)!.5!(static_end)$) node[dot, red]  – ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, red] ;
[red, route, dashed] ($(input_knowledge_A) + (.5, 0) + 0*(1, 0)$)  node[dot, red]  – ($(time_start)!.5!(time_end)$) node[dot, red]  – ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, red] ;

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
grid/.style=gray, dashed,
route/.style=very thick, draw opacity=.5,

(input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);
(input_knowledge_M) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_M) + (0, .5)$) – ($(input_knowledge_M) + (4, .5)$);
(input_knowledge_U) at ($(input_knowledge_M) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
(input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

(input_param_NO) at (.5,-.5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 4)$);
(input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 4)$);
(input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 4)$);
(input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

at ($(input_param_NO)!.5!(input_param_M) + (0, 4.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (2, 4.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (2, 2.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (2, 1.5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (2, -.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

(repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);
(repr_knowledge_M) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_M) + (0, .5)$) – ($(repr_knowledge_M) + (4, .5)$);
(repr_knowledge_U) at ($(repr_knowledge_M) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
(repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

(repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 4)$);
(repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 4)$);
(repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 4)$);
(repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

at ($(repr_param_NO)!.5!(repr_param_M) + (0, 4.5)$) Repr.;

[red, route] ($(input_knowledge_A) + (.5, 0) + 0*(1, 0)$)  node[dot, red]  – ($(static_start)!.5!(static_end)$) node[dot, red]  – ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, red] ;
[red, route, dashed] ($(input_knowledge_A) + (.5, 0) + 0*(1, 0)$)  node[dot, red]  – ($(time_start)!.5!(time_end)$) node[dot, red]  – ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, red] ;

Using the map of causal deep learning we can: (i) categorise and compare literature, as well as (ii) identify some areas that are not well explored. Using these two functionalities, we can perhaps attribute (i) to practitioners, and (ii) to researchers. A practitioner is faced with a problem they wish to solve. Using the map of CDL, the practitioner can map their available data onto the input field and search for a method in the representation field that would solve their needs. Perhaps guided by the required assumptions the practitioner is willing to make, the set of solutions is more digestible than scanning all the literature in CDL. The researcher may use the map differently. Rather than scanning the potential solutions, a researcher can use the map to scan which solutions are still lacking (or more likely, underrepresented).

Problems and goals. Learning a structured representation space, while retaining flexible assumptions, is difficult. Consider <ref> where we annotated learning a causally structured representation without any assumptions from arbitrary data with “Goal”. This learning setup is the most ambitious setup included in our map. It is also long thought to be impossible [Glymour et al., 2019, Geiger and Pearl, 1990, Meek, 2013, Eberhardt, 2017].

However, <ref> also shows the relative complexity of other setups. In principle, the less strict assumptions we make, the harder it becomes to narrow down the structure in our representation space. For some problem setups it may be sufficient to learn a flexible structure, which in turn allows for more flexible assumptions on the input. Similarly, if a problem requires a completely identified causal structure, our map shows that one may have make to some strict assumptions on the input. As such, the map of CDL exposes a certain balance between input assumptions and achievable structure.

§.§ Comparing methods

To show how one can use the map to compare methodologies, we take supervised learning as an example. Of course, CDL spans more than only supervised learning and so does our map.

To remind ourselves, supervised learning is a problem where we wish to map an input, to a label [Murphy, 2012]:

\begin{equation*}
m: \mathcal{D} \to \mathcal{Y},
\end{equation*}

where $\mathcal{D}$ is once again a dataset, but now including labels: $\{(X_i, Y_i) : i \in [N]\}$ with $X_i \in \mathcal{X}$ and $Y_i \in \mathcal{Y}$. The labels $Y_i \in \mathcal{Y}$ can be anything from a real variable ($\mathcal{Y} = \mathbb{R}$), to a binary label ($\mathcal{Y} = \{0, 1\}$).

As we discussed in <ref>, deep learning methods first map the data to a representation before it is mapped to the outcome-label [Goodfellow et al., 2016]: $m: \mathcal{D} \to \mathcal{H} \to \mathcal{Y}$. Here, $\mathcal{H}$ corresponds to the representation as in <ref>. As such, our discussion here does not concern $\mathcal{Y}$, but is instead focused on $\mathcal{H}$ and the structure it may respect.

Why use CDL for supervised learning? A fair question indeed. Typically, supervised learning models are evaluated only on the accuracy a model achieves on a hold-out test set. Yet, there is no immediate reason why a causal representation would help in this regard. Rather than maximising accuracy on a hold-out test set, one may resort to CDL to also achieve high accuracy on a subset that is not representative of the training data. Examples such as these include: domain adaptation [Zhang et al., 2021, Kyono and Van der Schaar, 2021], transfer learning [Rojas-Carulla et al., 2018, Magliacane et al., 2017], interpretability [Wang et al., 2020, Moraffah et al., 2020, Kim and Bastani, 2019, Xu et al., 2020], or general robustness [Wang et al., 2020, Kyono and van der Schaar, 2019, Müller et al., 2021, Bühlmann, 2020].

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
grid/.style=gray, dashed,
route/.style=very thick, draw opacity=.5,

[label=left:Unknown (U)] (input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);

[label=left:Plausible (P)] (input_knowledge_U) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
[label=left:Causal (C)] (input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

[label=below:NP] (input_param_NO) at (.5,-.5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 3)$);
[label=below:NM] (input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 3)$);
[label=below:Pa.] (input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 3)$);
[label=below:FK] (input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

at ($(input_param_NO)!.5!(input_param_M) + (0, 3.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (2, 3.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (2, 2.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (2, 1.5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (2, -1.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

(repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);

(repr_knowledge_U) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
(repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

[label=below:NP] (repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 3)$);
[label=below:NM] (repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 3)$);
[label=below:Pa.] (repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 3)$);
[label=below:FK] (repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

at ($(repr_param_NO)!.5!(repr_param_M) + (0, 3.5)$) Representation;

[DarkTurquoise, route] ($(input_knowledge_A) + (.3, -.25) + 0*(1, 0)$)  node[dot, DarkTurquoise]  to[out=315, in=180] ($(static_start)!.9!(static_end)$) node[dot, DarkTurquoise]  to[out=0, in=270] ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, DarkTurquoise] ;
[label=[text=DarkTurquoise]right:[Deng et al., 2009, Faragó and Lugosi, 1993]] at ($(repr_knowledge_A) + (4.5, 0)$) ;

[orange, route] ($(input_knowledge_A) + (.5, 0) + 1*(1, 0)$) node[dot, orange]  to[out=315, in=180] ($(static_start)!.7!(static_end)$) node[dot, orange]  to[out=0, in=270] ($(repr_knowledge_U) + (.5, 0) + 1*(1, 0)$) node[dot, orange] ;
[label=[text=orange]right:[Kyono et al., 2020, Kyono et al., 2021, Yao et al., 2021, Hollmann et al., 2022, Fatemi et al., 2021, Morales-Alvarez et al., 2021]] at ($(repr_knowledge_U) + (4.5, -.33)$) ;

[purple, route] ($(input_knowledge_C) + (.5, -.25) + 0*(1, 0)$) node[dot, purple]  to[out=315, in=180] ($(static_start)!.1!(static_end)$) node[dot, purple]  to[out=0, in=270] ($(repr_knowledge_C) + (.5, -.25)$) node[dot, purple] ;
[label=[text=purple]right:[Russo and Toni, 2022, Teshima and Sugiyama, 2021]] at ($(repr_knowledge_C) + (4.5, -.25)$) ;

[red, route] ($(input_knowledge_C) + (.5, .25) + 0*(1, 0)$) node[dot, red]  to[out=315, in=180] (static_start) node[dot, red]  to[out=0, in=180] ($(repr_knowledge_C) + (.5, .25)$) node[dot, red] ;
[label=[text=red]right: [Kancheti et al., 2022]] at ($(repr_knowledge_C) + (4.5, .25)$) ;

[Teal, route] ($(input_knowledge_U) + (.5, 0) + 0*(1, 0)$) node[dot, Teal]  to[out=315, in=180] ($(static_start)!.5!(static_end)$) node[dot, Teal]  to[out=0, in=270] ($(repr_knowledge_U) + (.7, .25) + 0*(1, 0)$) node[dot, Teal] ;
[label=[text=Teal]right:[Kohavi et al., 1996, Jiang et al., 2008, Jiang et al., 2012, Jiang et al., 2016]] at ($(repr_knowledge_U) + (4.5, 0) + (2.5, 0)$) ;

[SlateGray, route] ($(input_knowledge_A) + (.7, 0) + 0*(1, 0)$)  node[dot, SlateGray]  to [out=315, in=180] ($(static_start)!.8!(static_end)$) node[dot, SlateGray]  to[out=0, in=270] ($(repr_knowledge_U) + (.5, 0) + 0*(1, 0) + (-.2, -.25)$) node[dot, SlateGray] ;
[label=[text=SlateGray]right:[Chen et al., 2020]] at ($(repr_knowledge_U) + (4.5, .33)$) ;

[LimeGreen, route] ($(input_knowledge_U) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen]  to [out=270, in=180] ($(static_start)!.6!(static_end)$) node[dot, LimeGreen]  to[out=0, in=245]  ($(repr_knowledge_U) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen] ;
[label=[text=LimeGreen]right:[Duda et al., 1973, Langley et al., 1992]] at ($(repr_knowledge_U) + (4.5, 0)$) ;

Navigating (static) supervised learning. Here we focus only on methods that share the task of mapping data to a label in a supervised way. We discern between methods based on what input they expect (or assume) and what type of representation they learn before mapping to a label. Our map presents a straightforward way to categorise methods in causal deep learning. Doing this is useful for practitioners (to identify a suitable method), and to researchers (to identify a potential research gap). Here too: Non-parametric (NP), Noise models (NM), Parametric (Pa.), and Fully known (FK).

§.§ Developing methods

Let us discuss our map using a non-exhaustive list of some of the key tasks the map of CDL may help a researcher.

Identification. A big part in a researcher's workflow is to identify gaps in the literature. For researchers active in supervised learning, our map of CDL can be a useful tool to do exactly this. For example, from <ref> we learn that the models that take a fully known function as a parametric assumption are not well represented– they are not represented at all! Of course, this makes sense. If one assumes a fully known model, before commencing the learning task, there is no point learning it anymore.

Looking further, we find that mapping additive noise models with unknown structure, to additive noise model with structure actually are well represented. The reason for this is that recent contributions in differentiable structure learning are a great candidate to regularise models used for other tasks than structure learning. As such, a researcher would learn that there is indeed much competition in this field.

Navigation and related works. This brings us to a second task we can employ our map for: building a body of related works. The map will make it easier for researchers to find and learn about related works. Essentially enabling a platform for researchers to share their work with other interested researches. We explain in our discussion in <ref> how the map is a living document and how constant updating will help researchers and practitioners in all of the tasks described in this section.

Furthermore, the map allows researchers to think critically about the work they present. For example, in <ref> we clearly state that the “ultimate goal” to map data to a non-parametric causal structure without making any assumptions is simply impossible. Not only will this help researchers to discuss their proposal with a sense of realism, the same can be said about practitioners (and reviewers) alike.

Data. Beyond the above, the map also provides guidance for model evaluation. In particular, when evaluating a model, it is important to use data that actually matches the models input assumptions. Similarly for the benchmarks the proposal is compared against.

For example, if a method assumes a causal graph as input, there should be some assurance that the presented graph is indeed causal. One way to do this is by also provided some empirical evidence that this is the case, such as running clinical trials or assuming interventional data.

§.§ Using methods

Navigate. While the researcher's perspective is mostly based around identifying methods that don't exist, the practitioner's is the opposite. When faced with a certain problem, the practitioner may use the map to identify which methods assume the input the practitioner has available, while also solving the problem they wish to solve.

Finding a suitable method can be extremely challenging for practitioners as there are new methods proposed almost daily. This latter point is in fact one of the prime reasons why we propose the map in the first place.

Validation and education. On the other hand, it may be that the practitioner wishes to solve a problem that is not yet solved before (stumbling upon a gap in the literature). Or, more strikingly, they are faced with a problem that is simply impossible to solve.

Especially the latter could be an interesting use of our map: education. We strongly believe that the map of CDL can form a bridge between researches and practitioners. Educating which problems can be solved (which is communicated from research to practice), and which problems have to be solved (which is in turn communicated from practice to research).

As we have observed in <ref>, we find that there is a heavy focus on learning structure from nothing in the additive noise setting. But, perhaps this is not interesting from a practical point of view as it could be that practitioners are well aware of some conditional independence, or some parametric shape of their environment. Having clear communication between both parties may avoid researchers  to waste valuable resources and time to solve problems that need not be solved.

§.§ Categorising methods

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
grid/.style=gray, dashed,
route/.style=very thick, draw opacity=.5,

[label=left:Unknown (U)] (input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);
[label=left:Associative (A)] (input_knowledge_M) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_M) + (0, .5)$) – ($(input_knowledge_M) + (4, .5)$);
[label=left:Directed (D)] (input_knowledge_U) at ($(input_knowledge_M) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
[label=left:Causal (C)] (input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

[label=below:No] (input_param_NO) at (.5,-.5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 4)$);
[label=below:1st] (input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 4)$);
[label=below:2nd] (input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 4)$);
[label=below:Mult.] (input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

at ($(input_param_NO)!.5!(input_param_M) + (0, 4.5)$) Input;

[inner sep=0] (time_start) at ($(input_param_M) + (2, 4.5)$) ;
[inner sep=0] (time_end) at ($(input_param_M) + (2, 2.5)$) ;
[inner sep=0] (static_start) at ($(input_param_M) + (2, 1.5)$) ;
[inner sep=0] (static_end) at ($(input_param_M) + (2, -.5)$) ;

[very thick, blue] (time_start) – (time_end);
[very thick, blue] (static_start) – (static_end);

at ($(time_start) + (0, .3)$) Time;
at ($(static_start) + (0, .3)$) Static;

[label=left:U] (repr_knowledge_A) at ($(input_knowledge_A) + (7, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);
[label=left:A] (repr_knowledge_M) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_M) + (0, .5)$) – ($(repr_knowledge_M) + (4, .5)$);
[label=left:D] (repr_knowledge_U) at ($(repr_knowledge_M) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
[label=left:C] (repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

[label=below:No] (repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 4)$);
[label=below:1st] (repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 4)$);
[label=below:2nd] (repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 4)$);
[label=below:Mult.] (repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

at ($(repr_param_NO)!.5!(repr_param_M) + (0, 4.5)$) Representation;

[Goldenrod, route] ($(input_knowledge_U) + (.5, 0) + 1*(1, 0)$)  node[dot, Goldenrod]  – ($(time_start) - (0, .5)$) node[dot, Goldenrod]  – ($(repr_knowledge_U) + (.5, 0) + 0*(1, 0)$) node[dot, Goldenrod] ;
[dot, Goldenrod, label=right:<cit.>] at ($(repr_knowledge_U) + (4.5, .25)$) ;

[DarkTurquoise, route] ($(input_knowledge_A) + (.5, 0) + 0*(1, 0)$)  node[dot, DarkTurquoise]  – ($(time_start) - (0, .8)$) node[dot, DarkTurquoise]  – ($(repr_knowledge_A) + (.5, .25) + 0*(1, 0)$) node[dot, DarkTurquoise] ;
[dot, DarkTurquoise, label=right:<cit.>] at ($(repr_knowledge_A) + (4.5, .25)$) ;

[SlateGray, route] ($(input_knowledge_C) + (.5, 0) + 2*(1, 0)$)  node[dot, SlateGray]  – ($(time_start) - (0, .2)$) node[dot, SlateGray]  – ($(repr_knowledge_C) + (.5, 0) + 0*(1, 0)$) node[dot, SlateGray] ;
[dot, SlateGray, label=right:<cit.>] at ($(repr_knowledge_C) + (4.5, 0)$) ;

[purple, route] ($(input_knowledge_C) + (.5, 0) + 0*(1, 0)$) node[dot, purple]  – ($(static_start) - (0, .3)$) node[dot, purple]  – ($(repr_knowledge_A) + (.5, -.25)$) node[dot, purple] ;
[dot, purple, label=right:Hassanpour and Greiner, 2019] at ($(repr_knowledge_A) + (4.5, -.25)$) ;

[orange, route] ($(input_knowledge_A) + (.5, 0) + 1*(1, 0)$) node[dot, orange]  – ($(static_start) + (0, -.6)$) node[dot, orange]  – ($(repr_knowledge_U) + (.5, 0) + 1*(1, 0)$) node[dot, orange] ;
[dot, orange, label=right:<cit.>] at ($(repr_knowledge_U) + (4.5, -.25)$) ;

[DarkBlue, route] ($(input_knowledge_A) + (.5, 0) + 3*(1, 0)$) node[dot, DarkBlue]  – ($(static_start) + (0, -.9)$) node[dot, DarkBlue]  – ($(repr_knowledge_C) + (.5, 0) + 3*(1, 0)$) node[dot, DarkBlue] ;
[dot, DarkBlue, label=right:<cit.>] at ($(repr_knowledge_C) + (4.5, .32)$) ;

[LimeGreen, route] ($(input_knowledge_A) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen]  – ($(static_start) + (0, -1.2)$) node[dot, LimeGreen]  – ($(repr_knowledge_C) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen] ;
[dot, LimeGreen, label=right:Hoyer et al., 2008] at ($(repr_knowledge_C) + (4.5, -.32)$) ;

The map of causal deep learning.

An example that doesn't do strict causality

Hassanpour and Greiner, 2019
An example that outputs a lower form of representation than what's given as input

An example using temporal (Granger) causality

An example operating on temporal causality, with minimal input requirements (compared to e.g. Hassanpour and Greiner, 2019).

An example leveraging directed structures. <cit.> do not assume the directed structures to have causal meaning. However, one could argue that as <cit.> is a temporal model, that causes precede effects which yields an implicit causal model.

§.§ Data

dot/.style=circle, fill=black, line width=0,  minimum size=2mm, inner sep=0,
grid/.style=gray, dashed,
route/.style=very thick, draw opacity=.5,

[label=left:Unknown (U)] (input_knowledge_A) at (0,0) ;
[grid] ($(input_knowledge_A) + (0, .5)$) – ($(input_knowledge_A) + (4, .5)$);

[label=left:Plausible (P)] (input_knowledge_U) at ($(input_knowledge_A) + (0, 1)$) ;
[grid] ($(input_knowledge_U) + (0, .5)$) – ($(input_knowledge_U) + (4, .5)$);
[label=left:Causal (C)] (input_knowledge_C) at ($(input_knowledge_U) + (0, 1)$) ;

[label=below:NP] (input_param_NO) at (.5,-.5) ;
[grid] ($(input_param_NO) + (.5, 0)$) – ($(input_param_NO) + (.5, 3)$);
[label=below:Add.] (input_param_1) at ($(input_param_NO) + (1, 0)$) ;
[grid] ($(input_param_1) + (.5, 0)$) – ($(input_param_1) + (.5, 3)$);
[label=below:Pa.] (input_param_2) at ($(input_param_1) + (1, 0)$) ;
[grid] ($(input_param_2) + (.5, 0)$) – ($(input_param_2) + (.5, 3)$);
[label=below:FK] (input_param_M) at ($(input_param_2) + (1, 0)$) ;

[very thick] ($(input_knowledge_A) - (0, .5)$) – ($(input_knowledge_C) + (0, .5)$) – ($(input_knowledge_C) + (4, .5)$) – ($(input_param_M) + (.5, 0)$) – cycle;

at ($(input_param_NO)!.5!(input_param_M) + (0, 3.5)$) Data;

(repr_knowledge_A) at ($(input_knowledge_A) + (5.2, 0)$) ;
[grid] ($(repr_knowledge_A) + (0, .5)$) – ($(repr_knowledge_A) + (4, .5)$);

(repr_knowledge_U) at ($(repr_knowledge_A) + (0, 1)$) ;
[grid] ($(repr_knowledge_U) + (0, .5)$) – ($(repr_knowledge_U) + (4, .5)$);
(repr_knowledge_C) at ($(repr_knowledge_U) + (0, 1)$) ;

[label=below:NP] (repr_param_NO) at ($(repr_knowledge_A) + (.5, -.5)$) ;
[grid] ($(repr_param_NO) + (.5, 0)$) – ($(repr_param_NO) + (.5, 3)$);
[label=below:Add.] (repr_param_1) at ($(repr_param_NO) + (1, 0)$) ;
[grid] ($(repr_param_1) + (.5, 0)$) – ($(repr_param_1) + (.5, 3)$);
[label=below:Pa.] (repr_param_2) at ($(repr_param_1) + (1, 0)$) ;
[grid] ($(repr_param_2) + (.5, 0)$) – ($(repr_param_2) + (.5, 3)$);
[label=below:FK] (repr_param_M) at ($(repr_param_2) + (1, 0)$) ;

[very thick] ($(repr_knowledge_A) - (0, .5)$) – ($(repr_knowledge_C) + (0, .5)$) – ($(repr_knowledge_C) + (4, .5)$) – ($(repr_param_M) + (.5, 0)$) – cycle;

at ($(repr_param_NO)!.5!(repr_param_M) + (0, 3.5)$) Model assumptions;

[DarkTurquoise, route] ($(input_knowledge_A) + (.3, -.25) + 0*(1, 0)$)  node[dot, DarkTurquoise]  to[out=315, in=225] ($(repr_knowledge_A) + (.5, 0) + 0*(1, 0)$) node[dot, DarkTurquoise] ;
[label=[text=DarkTurquoise]right:<cit.>] at ($(repr_knowledge_A) + (4.5, .32)$) ;

[orange, route] ($(input_knowledge_A) + (.5, 0) + 3*(1, 0)$) node[dot, orange]  to[out=45, in=135] ($(repr_knowledge_A) + (.5, 0) + 1*(1, 0)$) node[dot, orange] ;
[orange, route] ($(input_knowledge_A) + (.3, .25) + 0*(1, 0)$) node[dot, orange]  to[out=45, in=135] ($(repr_knowledge_A) + (.5, 0) + 1*(1, 0)$);
[label=[text=orange]right:<cit.>] at ($(repr_knowledge_A) + (4.5, 0)$) ;

[purple, route] ($(input_knowledge_C) + (.5, 0) + 3*(1, 0)$) node[dot, purple]  – ($(repr_knowledge_C) + (.5, 0)$) node[dot, purple] ;
[label=[text=purple]right:Hassanpour and Greiner, 2019] at ($(repr_knowledge_C) + (4.5, -.25)$) ;

[SlateGray, route] ($(input_knowledge_A) + (.7, 0) + 0*(1, 0)$)  node[dot, SlateGray]  to [out=45, in=225] ($(repr_knowledge_C) + (.5, 0) + 2*(1, 0)$) node[dot, SlateGray] ;
[label=[text=SlateGray]right:<cit.>] at ($(repr_knowledge_C) + (4.5, .25)$) ;

[Goldenrod, route] ($(input_knowledge_U) + (.5, 0) + 1*(1, 0)$)  node[dot, Goldenrod]  – ($(repr_knowledge_U) + (.5, 0) + 1*(1, 0)$) node[dot, Goldenrod] ;
[label=[text=Goldenrod]right:<cit.>] at ($(repr_knowledge_U) + (4.5, 0)$) ;

[LimeGreen, route] ($(input_knowledge_A) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen]  to [out=315, in=225] ($(repr_knowledge_A) + (.5, 0) + 2*(1, 0)$) node[dot, LimeGreen] ;
[label=[text=LimeGreen]right:Hoyer et al., 2008] at ($(repr_knowledge_A) + (4.5, -.32)$) ;

Categorising data. Using our map we can quickly match a model's input assumptions with the actual properties of the data used in the experiments of the corresponding paper. On the left we categorise the used data, and on the right we categorise the assumed input properties (as they were reported in <ref> previously). Each paper is listed with either a “” to indicated matching data with input assumptions, and conversely with “” when data and assumptions are conflicting.

§ DISCUSSION

We hope that our map organises and identifies the problems, methods, challenges, and future directions of causal deep learning. Doing so may help researchers and practitioners alike. Not only do we believe that the map enables clear communication between both, we thing that using the map will make the tasks associated with both researchers and practitioners much easier. Naturally, the use of our map heavily depends on a sense of maintained relevance. Not only in supervised learning (for which we completed a small exercise in <ref>), but also fields such as reinforcement learning, generative models, reasoning, etc. As such, we consider this paper to be a living paper.

A living paper. A living paper should be understood as a paper that receives frequent updates. Not only by adding in newly proposed methods, but also by changing the structure of the map to fit the needs of the field of causal deep learning.
We believe strongly that the only way this intense field can be accurately tracked is by constant monitoring and refining our map. As such, we will provide, in the future, an online forum where we can track, discuss, and propose changes to any part of our paper. This includes the map itself, related work, and our discussion.

§.§.§ Acknowledgements

We wish to already acknowledge Kun Zhang (CMU), Trent Kyono (Meta), and Ruibo Tu (KTH) for discussing this work with us. We truly value their input, as well as future input from community members.

[Hume, 1751]
David Hume.
Philosophical essays concerning human understanding.
Number 35. M. Cooper, 1751.

[Pearl and Mackenzie, 2018]
Judea Pearl and Dana Mackenzie.
The book of why: the new science of cause and effect.
Basic books, 2018.

[Lewis, 1974]
David Lewis.
The journal of philosophy, 700 (17):0
556–567, 1974.

[Lewis, 1979]
David Lewis.
Counterfactual dependence and time's arrow.
Noûs, pages 455–476, 1979.

[Pearl, 2009]
Judea Pearl.
Cambridge university press, 2009.

[Rebane and Pearl, 2013]
George Rebane and Judea Pearl.
The recovery of causal poly-trees from statistical data.
arXiv preprint arXiv:1304.2736, 2013.

[Simon and Rescher, 1966]
Herbert A Simon and Nicholas Rescher.
Cause and counterfactual.
Philosophy of science, 330 (4):0 323–340,

[Collingwood and Collingwood, 2001]
Robin George Collingwood and Robin George Collingwood.
An essay on metaphysics.
Oxford University Press, 2001.

[Gasking, 1955]
Douglas Gasking.
Causation and recipes.
Mind, 640 (256):0 479–487, 1955.

[Menzies and Price, 1993]
Peter Menzies and Huw Price.
Causation as a secondary quality.
The British Journal for the Philosophy of Science, 440
(2):0 187–203, 1993.

[Von Wright, 2004]
Georg Henrik Von Wright.
Explanation and understanding.
Cornell University Press, 2004.

[Woodward, 2005]
James Woodward.
Making things happen: A theory of causal explanation.
Oxford university press, 2005.

[Salmon, 1984]
Wesley C Salmon.
Scientific explanation and the causal structure of the world.
Princeton University Press, 1984.

[Williamson, 2011]
Jon Williamson.
Mechanistic theories of causality part i.
Philosophy Compass, 60 (6):0 421–432, 2011.

[Wright, 1920]
Sewall Wright.
The relative importance of heredity and environment in determining
the piebald pattern of guinea-pigs.
Proceedings of the National Academy of Sciences, 60
(6):0 320–332, 1920.

[Bareinboim et al., 2022]
Elias Bareinboim, Juan D Correa, Duligur Ibeling, and Thomas Icard.
On pearl’s hierarchy and the foundations of causal inference.
In Probabilistic and Causal Inference: The Works of Judea
Pearl, pages 507–556. 2022.

[Vaswani et al., 2017]
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones,
Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin.
Attention is all you need.
Advances in neural information processing systems, 30, 2017.

[Williams and Rasmussen, 2006]
Christopher KI Williams and Carl Edward Rasmussen.
Gaussian processes for machine learning, volume 2.
MIT press Cambridge, MA, 2006.

[Montgomery et al., 2021]
Douglas C Montgomery, Elizabeth A Peck, and G Geoffrey Vining.
Introduction to linear regression analysis.
John Wiley & Sons, 2021.

[Pearl, 2019]
Judea Pearl.
The seven tools of causal inference, with reflections on machine
Communications of the ACM, 620 (3):0 54–60,

[Hestness et al., 2019]
Joel Hestness, Newsha Ardalani, and Gregory Diamos.
Beyond human-level accuracy: Computational challenges in deep
In Proceedings of the 24th Symposium on Principles and Practice
of Parallel Programming, pages 1–14, 2019.

[Cho et al., 2015]
Junghwan Cho, Kyewook Lee, Ellie Shin, Garry Choy, and Synho Do.
How much data is needed to train a medical image deep learning system
to achieve necessary high accuracy?
arXiv preprint arXiv:1511.06348, 2015.

[Litjens et al., 2016]
Geert Litjens, Clara I Sánchez, Nadya Timofeeva, Meyke Hermsen, Iris
Nagtegaal, Iringo Kovacs, Christina Hulsbergen-Van De Kaa, Peter Bult, Bram
Van Ginneken, and Jeroen Van Der Laak.
Deep learning as a tool for increased accuracy and efficiency of
histopathological diagnosis.
Scientific reports, 60 (1):0 1–11, 2016.

[Krizhevsky et al., 2017]
Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton.
Imagenet classification with deep convolutional neural networks.
Communications of the ACM, 600 (6):0 84–90,

[Deng et al., 2009]
Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei.
Imagenet: A large-scale hierarchical image database.
In 2009 IEEE conference on computer vision and pattern
recognition, pages 248–255. Ieee, 2009.

[Russakovsky et al., 2015]
Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma,
Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al.
Imagenet large scale visual recognition challenge.
International journal of computer vision, 1150
(3):0 211–252, 2015.

[Berrevoets et al., 2021]
Jeroen Berrevoets, Alicia Curth, Ioana Bica, Eoin McKinney, and Mihaela van der
Disentangled counterfactual recurrent networks for treatment effect
inference over time.
arXiv preprint arXiv:2112.03811, 2021.

[Nikolenko, 2021]
Sergey I Nikolenko.
Synthetic data for deep learning, volume 174.
Springer, 2021.

[Rombach et al., 2022]
Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn
High-resolution image synthesis with latent diffusion models.
In Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition, pages 10684–10695, 2022.

[Kobyzev et al., 2020]
Ivan Kobyzev, Simon JD Prince, and Marcus A Brubaker.
Normalizing flows: An introduction and review of current methods.
IEEE transactions on pattern analysis and machine
intelligence, 430 (11):0 3964–3979, 2020.

[van Breugel et al., 2021]
Boris van Breugel, Trent Kyono, Jeroen Berrevoets, and Mihaela van der Schaar.
Decaf: Generating fair synthetic data using causally-aware generative
Advances in Neural Information Processing Systems,
34:0 22221–22233, 2021.

[Hunter et al., 2012]
David Hunter, Hao Yu, Michael S Pukish III, Janusz Kolbusz, and Bogdan M
Selection of proper neural network sizes and architectures—a
comparative study.
IEEE Transactions on Industrial Informatics, 80
(2):0 228–240, 2012.

[Bebis and Georgiopoulos, 1994]
George Bebis and Michael Georgiopoulos.
Feed-forward neural networks.
IEEE Potentials, 130 (4):0 27–31, 1994.

[Mostafa and Wang, 2019]
Hesham Mostafa and Xin Wang.
Parameter efficient training of deep convolutional neural networks by
dynamic sparse reparameterization.
In International Conference on Machine Learning, pages
4646–4655. PMLR, 2019.

[Carter et al., 2015]
Brian D. Carter, Christian C. Abnet, Diane Feskanich, Neal D. Freedman,
Patricia Hartge, Cora E. Lewis, Judith K. Ockene, Ross L. Prentice, Frank E.
Speizer, Michael J. Thun, and Eric J. Jacobs.
Smoking and mortality — beyond established causes.
New England Journal of Medicine, 3720 (7):0
631–640, 2015.
URL <https://doi.org/10.1056/NEJMsa1407211>.
PMID: 25671255.

[Koller and Friedman, 2009]
Daphne Koller and Nir Friedman.
Probabilistic graphical models: principles and techniques.
MIT press, 2009.

[Sun et al., 2006]
Xiaohai Sun, Dominik Janzing, and Bernhard Schölkopf.
Causal inference by choosing graphs with most plausible markov
In Ninth International Symposium on Artificial Intelligence and
Mathematics (AIMath 2006), pages 1–11, 2006.

[Verma and Pearl, 1990]
Thomas S. Verma and Judea Pearl.
Equivalence and synthesis of causal models.
In Proceedings of the Sixth Conference on Uncertainty in
Artificial Intelligence, 1990.

[Sheikh et al., 2021]
Mahdi Sheikh, Anush Mukeriya, Oxana Shangina, Paul Brennan, and David Zaridze.
Postdiagnosis smoking cessation and reduced risk for lung cancer
progression and mortality: a prospective cohort study.
Annals of internal medicine, 1740 (9):0
1232–1239, 2021.

[Lee and Bareinboim, 2018]
Sanghack Lee and Elias Bareinboim.
Structural causal bandits: where to intervene?
Advances in Neural Information Processing Systems, 31, 2018.

[Lee and Bareinboim, 2019]
Sanghack Lee and Elias Bareinboim.
Structural causal bandits with non-manipulable variables.
In Proceedings of the AAAI Conference on Artificial
Intelligence, volume 33, pages 4164–4172, 2019.

[Kyono et al., 2020]
Trent Kyono, Yao Zhang, and Mihaela van der Schaar.
Castle: regularization via auxiliary causal graph discovery.
Advances in Neural Information Processing Systems,
33:0 1501–1512, 2020.

[Hassanpour and Greiner, 2019]
Negar Hassanpour and Russell Greiner.
Learning disentangled representations for counterfactual regression.
In International Conference on Learning Representations, 2019.

[Zhang and Hyvarinen, 2012]
Kun Zhang and Aapo Hyvarinen.
On the identifiability of the post-nonlinear causal model.
arXiv preprint arXiv:1205.2599, 2012.

[Shimizu et al., 2011]
Shohei Shimizu, Takanori Inazumi, Yasuhiro Sogawa, Aapo Hyvarinen, Yoshinobu
Kawahara, Takashi Washio, Patrik O Hoyer, Kenneth Bollen, and Patrik Hoyer.
Directlingam: A direct method for learning a linear non-gaussian
structural equation model.
Journal of Machine Learning Research-JMLR, 120
(Apr):0 1225–1248, 2011.

[Hoyer et al., 2008]
Patrik Hoyer, Dominik Janzing, Joris M Mooij, Jonas Peters, and Bernhard
Nonlinear causal discovery with additive noise models.
Advances in neural information processing systems, 21, 2008.

[Peters et al., 2017]
Jonas Peters, Dominik Janzing, and Bernhard Schölkopf.
Elements of causal inference: foundations and learning
The MIT Press, 2017.

[Schmidt-Hieber, 2020]
Johannes Schmidt-Hieber.
Nonparametric regression using deep neural networks with relu
activation function.
The Annals of Statistics, 480 (4):0
1875–1897, 2020.

[Granger, 1969]
Clive WJ Granger.
Investigating causal relations by econometric models and
cross-spectral methods.
Econometrica: journal of the Econometric Society, pages
424–438, 1969.

[Glymour et al., 2019]
Clark Glymour, Kun Zhang, and Peter Spirtes.
Review of causal discovery methods based on graphical models.
Frontiers in genetics, 10:0 524, 2019.

[Geiger and Pearl, 1990]
Dan Geiger and Judea Pearl.
On the logic of causal models.
In Machine Intelligence and Pattern Recognition, volume 9,
pages 3–14. Elsevier, 1990.

[Meek, 2013]
Christopher Meek.
Strong completeness and faithfulness in bayesian networks.
arXiv preprint arXiv:1302.4973, 2013.

[Eberhardt, 2017]
Frederick Eberhardt.
Introduction to the foundations of causal discovery.
International Journal of Data Science and Analytics,
30 (2):0 81–91, 2017.

[Murphy, 2012]
Kevin P Murphy.
Machine learning: a probabilistic perspective.
MIT press, 2012.

[Goodfellow et al., 2016]
Ian Goodfellow, Yoshua Bengio, and Aaron Courville.
Deep learning.
MIT press, 2016.

[Zhang et al., 2021]
Xiheng Zhang, Yongkang Wong, Xiaofei Wu, Juwei Lu, Mohan Kankanhalli, Xiangdong
Li, and Weidong Geng.
Learning causal representation for training cross-domain pose
estimator via generative interventions.
In Proceedings of the IEEE/CVF International Conference on
Computer Vision, pages 11270–11280, 2021.

[Kyono and Van der Schaar, 2021]
Trent Kyono and Mihaela Van der Schaar.
Exploiting causal structure for robust model selection in
unsupervised domain adaptation.
IEEE Transactions on Artificial Intelligence, 20
(6):0 494–507, 2021.

[Rojas-Carulla et al., 2018]
Mateo Rojas-Carulla, Bernhard Schölkopf, Richard Turner, and Jonas Peters.
Invariant models for causal transfer learning.
The Journal of Machine Learning Research, 190
(1):0 1309–1342, 2018.

[Magliacane et al., 2017]
Sara Magliacane, Thijs van Ommen, Tom Claassen, Stephan Bongers, Philip
Versteeg, and Joris M Mooij.
Causal transfer learning.
arXiv preprint arXiv:1707.06422, 2017.

[Wang et al., 2020]
Dong Wang, Yuewei Yang, Chenyang Tao, Zhe Gan, Liqun Chen, Fanjie Kong, Ricardo
Henao, and Lawrence Carin.
Proactive pseudo-intervention: Causally informed contrastive learning
for interpretable vision models.
arXiv preprint arXiv:2012.03369, 2020a.

[Moraffah et al., 2020]
Raha Moraffah, Mansooreh Karami, Ruocheng Guo, Adrienne Raglin, and Huan Liu.
Causal interpretability for machine learning-problems, methods and
ACM SIGKDD Explorations Newsletter, 220 (1):0
18–33, 2020.

[Kim and Bastani, 2019]
Carolyn Kim and Osbert Bastani.
Learning interpretable models with causal guarantees.
arXiv preprint arXiv:1901.08576, 2019.

[Xu et al., 2020]
Guandong Xu, Tri Dung Duong, Qian Li, Shaowu Liu, and Xianzhi Wang.
Causality learning: a new perspective for interpretable machine
arXiv preprint arXiv:2006.16789, 2020.

[Wang et al., 2020]
Tan Wang, Jianqiang Huang, Hanwang Zhang, and Qianru Sun.
Visual commonsense representation learning via causal inference.
In Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition Workshops, pages 378–379, 2020b.

[Kyono and van der Schaar, 2019]
Trent Kyono and Mihaela van der Schaar.
Improving model robustness using causal knowledge.
arXiv preprint arXiv:1911.12441, 2019.

[Müller et al., 2021]
Jens Müller, Robert Schmier, Lynton Ardizzone, Carsten Rother, and Ullrich
Learning robust models using the principle of independent causal
In DAGM German Conference on Pattern Recognition, pages
79–110. Springer, 2021.

[Bühlmann, 2020]
Peter Bühlmann.
Invariance, causality and robustness.
Statistical Science, 350 (3):0 404–426, 2020.

[Faragó and Lugosi, 1993]
András Faragó and Gábor Lugosi.
Strong universal consistency of neural network classifiers.
IEEE Transactions on Information Theory, 390
(4):0 1146–1151, 1993.

[Kyono et al., 2021]
Trent Kyono, Yao Zhang, Alexis Bellot, and Mihaela van der Schaar.
Miracle: Causally-aware imputation via learning missing data
Advances in Neural Information Processing Systems,
34:0 23806–23817, 2021.

[Yao et al., 2021]
Liuyi Yao, Yaliang Li, Bolin Ding, Jingren Zhou, Jinduo Liu, Mengdi Huai, and
Jing Gao.
Path-specific causal fair prediction via auxiliary graph structure

[Hollmann et al., 2022]
Noah Hollmann, Samuel Müller, Katharina Eggensperger, and Frank Hutter.
Tabpfn: A transformer that solves small tabular classification
problems in a second.
arXiv preprint arXiv:2207.01848, 2022.

[Fatemi et al., 2021]
Bahare Fatemi, Layla El Asri, and Seyed Mehran Kazemi.
Slaps: Self-supervision improves structure learning for graph neural
Advances in Neural Information Processing Systems,
34:0 22667–22681, 2021.

[Morales-Alvarez et al., 2021]
Pablo Morales-Alvarez, Angus Lamb, Simon Woodhead, Simon Peyton Jones,
Miltiadis Allamanis, and Cheng Zhang.
Vicause: Simultaneous missing value imputation and causal discovery
with groups.
arXiv preprint arXiv:2110.08223, 2021.

[Russo and Toni, 2022]
Fabrizio Russo and Francesca Toni.
Causal discovery and injection for feed-forward neural networks.
arXiv preprint arXiv:2205.09787, 2022.

[Teshima and Sugiyama, 2021]
Takeshi Teshima and Masashi Sugiyama.
Incorporating causal graphical prior knowledge into predictive
modeling via simple data augmentation.
In Cassio de Campos and Marloes H. Maathuis, editors,
Proceedings of the Thirty-Seventh Conference on Uncertainty in
Artificial Intelligence, volume 161 of Proceedings of Machine Learning
Research, pages 86–96. PMLR, 27–30 Jul 2021.
URL <https://proceedings.mlr.press/v161/teshima21a.html>.

[Kancheti et al., 2022]
Sai Srinivas Kancheti, Abbavaram Gowtham Reddy, Vineeth N Balasubramanian, and
Amit Sharma.
Matching learned causal effects of neural networks with domain
In Kamalika Chaudhuri, Stefanie Jegelka, Le Song, Csaba Szepesvari,
Gang Niu, and Sivan Sabato, editors, Proceedings of the 39th
International Conference on Machine Learning, volume 162 of
Proceedings of Machine Learning Research, pages 10676–10696. PMLR,
17–23 Jul 2022.
URL <https://proceedings.mlr.press/v162/kancheti22a.html>.

[Kohavi et al., 1996]
Ron Kohavi et al.
Scaling up the accuracy of naive-bayes classifiers: A decision-tree
In Kdd, volume 96, pages 202–207, 1996.

[Jiang et al., 2008]
Liangxiao Jiang, Harry Zhang, and Zhihua Cai.
A novel bayes model: Hidden naive bayes.
IEEE Transactions on knowledge and data engineering,
210 (10):0 1361–1371, 2008.

[Jiang et al., 2012]
Liangxiao Jiang, Zhihua Cai, Dianhong Wang, and Harry Zhang.
Improving tree augmented naive bayes for class probability
Knowledge-Based Systems, 26:0 239–245, 2012.

[Jiang et al., 2016]
Liangxiao Jiang, Chaoqun Li, Shasha Wang, and Lungan Zhang.
Deep feature weighting for naive bayes and its application to text
Engineering Applications of Artificial Intelligence,
52:0 26–39, 2016.

[Chen et al., 2020]
Yu Chen, Lingfei Wu, and Mohammed Zaki.
Iterative deep graph learning for graph neural networks: Better and
robust node embeddings.
In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin,
editors, Advances in Neural Information Processing Systems, volume 33,
pages 19314–19326. Curran Associates, Inc., 2020.

[Duda et al., 1973]
Richard O Duda, Peter E Hart, et al.
Pattern classification and scene analysis, volume 3.
Wiley New York, 1973.

[Langley et al., 1992]
Pat Langley, Wayne Iba, Kevin Thompson, et al.
An analysis of bayesian classifiers.
In Aaai, volume 90, pages 223–228, 1992.