Can Large Language Models Infer Causation from Correlation?

Introduction

Causal inference, i.e., the ability to establish the correct causal relationships between variables or events, is fundamental to human intelligence. There are two distinct ways this causal inference capability can be acquired: one through empirical knowledge, e.g., we know from common sense that touching a hot stove will get us burned; the other through pure causal reasoning, as causality can be formally argued and reasoned about using known procedures and rules from causal inference (Spirtes et al., 2000; Pearl, 2009; Peters et al., 2017). One example is that we have the a priori knowledge that the correlation between A and B does not necessarily imply causality. This is a formal rule that holds true regardless of the realizations of the variables A and B.

With the rise of large language models (LLMs) (Radford et al., 2019; Devlin et al., 2019; Ouyang et al., 2022; Zhang et al., 2022; OpenAI, 2023, inter alia), a crucial research question is whether they can do causal reasoning well. Recent studies have pointed out that LLMs are “causal parrots,” which recite the causal knowledge in the training data (Zečević et al., 2023). Moreover, the vast majority of studies frame causal reasoning as a skill to navigate around empirical knowledge (Gordon et al., 2012; Sap et al., 2019a; b; Qin et al., 2019; Bhagavatula et al., 2020), and also treat LLMs as a knowledge base when evaluating its causal skills (Kıcıman et al., 2023; Tu et al., 2023; Xie et al., 2023). However, all the above lines of research frame causality as empirical knowledge, thus relying heavily on the quality and the coverage of the training data, overlooking the great potential of the formal causal reasoning skills to process correlational information to causal conclusions.

Drawing inspirations from technical studies on causal discovery (Spirtes et al., 2000; Spirtes & Zhang, 2016; Glymour et al., 2019), we formulate a novel task for NLP, correlation-to-causation inference (Corr2Cause), which is an important skill for LLMs. Imagine the scenario in Figure 1, where the training corpus does not tediously cover every causal relation, but more pervasively talk about correlations, such as which events tend to co-occur. Learning a good Corr2Cause skill can enable LLMs to draw causal relations behind the mere correlational information on the surface. For example, several decades ago, there might be an observation that female university students tend to perform better, but behind the correlational statistics is the causal graph that female students have to achieve extra good performance to get into universities as the first place.

To this end, we collect the Corr2Cause dataset, the first dataset to test the pure causal reasoning abilities of LLMs. All the questions in this dataset are centered around testing when it is valid or invalid to infer causation from correlation. To systematically compose this dataset, we ground our generalization process in the formal framework of causal discovery (Spirtes et al., 1993; 2000; Glymour et al., 2016; Spirtes & Zhang, 2016), which provides rules about how to deduce causal relations among variables given their statistical correlation in the observational data. We generate more than 200K data points, and label a correlation-causation statement pair as valid if and only if there is a bijective mapping between the statistical correlation and the underlying causality.

Based on our Corr2Cause dataset with 200K samples, we investigate two main research questions: (1) How well do existing LLMs perform on this task? (2) Can existing LLMs be re-trained or re-purposed on this task and obtain robust causal inference skills? Through extensive experiments, we show empirically that none of the seventeen existing LLMs we investigate perform well on this pure causal inference task. We also show that although LLMs can demonstrate better performance after being finetuned on the data, the causal inference skills attained by them are not robust. In summary, our contributions are as follows:

We propose the novel task of Corr2Cause, to probe an aspect of LLM’s reasoning ability, pure causal inference;

We compose a dataset of over 200K samples, using insights from causal discovery;

We evaluate the performance of seventeen LLMs on our dataset, finding that all of them perform poorly, close to the random baseline;

We further explored whether LLMs can learn the skill through finetuning, and find that LLMs fail to robustly acquire this skill in out-of-distribution settings. Finally, we suggest future work to explore more ways to enhance the pure causal inference skill in LLMs.

Preliminaries: Causal Inference

A directed graphical causal model (DGCM) is a commonly used representation to express the causal relations among a set of variables. Given a set of $N$ variables $\bm{X}=\{X_{1},\dots,X_{N}\}$, we can encode the causal relations among them using a directed graph $\mathcal{G}:=(\bm{X},\bm{E})$, where $\bm{E}$ is the set of directed edges. Each edge $e_{i,j}\in\bm{E}$ represents a causal link $X_{i}\rightarrow X_{j}$, meaning that $X_{i}$ is a direct cause of $X_{j}$. In the context of this work, we take the common assumption of directed acyclic graphs (DAGs), which most causal discovery methods use (Glymour et al., 2019), as graphs with cycles can make the causal discovery process arbitrarily hard.

Following the graph-theoretic terminology, we use an analogy of the ancestry tree to denote the relations between two variables. For example, we call $X_{i}$ as a parent of $X_{j}$ if there is a directed edge $X_{i}\rightarrow X_{j}$ in the graph, and, thus, $X_{j}$ is a child of $X_{i}$. Similarly, we denote $X_{i}$ as an ancestor of $X_{j}$ if there exists a directed path from $X_{i}$ to $X_{j}$, and, thus, $X_{j}$ is a descendent of $X_{i}$. Note that a parent is a special case of an ancestor where the directed path has a length of 1.

For convenience, we also introduce the notions for some special three-variable relations. Given two variables $X_{i}$ and $X_{j}$, we call a third variable $X_{k}$ a confounder (i.e., common cause) if $X_{k}$ is a parent of both $X_{i}$ and $X_{j}$; a collider (i.e., common effect) if $X_{k}$ is a child of both $X_{i}$ and $X_{j}$; and a mediator if $X_{k}$ is both a child of $X_{i}$, and a parent of $X_{j}$.

2 D-Separation and Markov Property

D-separation (Pearl, 1988) is a fundamental concept in graphical models used to determine whether two sets of nodes $\bm{X}$ and $\bm{Y}$ in a DAG $\mathcal{G}$ are conditionally independent given a third set of nodes $\bm{Z}$, where the three sets are disjoint. We say that $\bm{X}$ and $\bm{Y}$ are d-separated by $\bm{Z}$ if all paths between any node in $\bm{X}$ and any node in $\bm{Y}$ are blocked by the conditioning set $\bm{Z}$. A path between $\bm{X}$ and $\bm{Y}$ is blocked by $\bm{Z}$ if there exists a node $A\in\bm{Z}$ which satisfies one of the following conditions: $A$ is the parent node in a fork structure on the path (i.e., $\cdot\leftarrow A\rightarrow\cdot$); $A$ is the mediator node in a chain structure on the path (i.e., $\cdot\rightarrow A\rightarrow\cdot$); or in any collider structure on the path (i.e., $\cdot\rightarrow A\leftarrow\cdot$), $\bm{Z}$ does not contain $A$ or its descendants.

Markov Property

Markov Equivalence of Graphs

We denote two DAGs as Markov equivalent if they induce the same joint distribution $P(\bm{X})$. The set of DAGs that are Markov equivalent to each other is called a Markov equivalence class (MEC). Causal graphs in the same MEC can be easily identified since they have the same skeleton (i.e., undirected edges) and V-structures (i.e., structures in the form of $A\rightarrow B\leftarrow C$ where $A$ and $C$ are not connected).

Obviously, there is a one-to-many mapping (i.e., surjection) between the causal graph and statistical distribution. Namely, each causal graph sufficiently determines a statistical distribution, but from a statistical distribution, we cannot necessarily induce a unique causal graph. This is why we say “correlation does not necessarily mean causation”.

3 Causal Discovery

Causal discovery aims to learn the causal relations by analyzing statistical properties in the observational data (Spirtes et al., 1993; 2000; Glymour et al., 2016; Spirtes & Zhang, 2016; Glymour et al., 2019). It can be achieved through constraint-based methods (Spirtes et al., 2000), score-based methods (Chickering, 2002), or other methods taking advantage of the functional causal models (Shimizu et al., 2006; Hoyer et al., 2008; Zhang & Hyvärinen, 2009).

To fit for the spirit of this paper to infer from correlation (expressed in natural language) to causation, we base our dataset design on the widely-used Peter-Clark (PC) algorithm (Spirtes et al., 2000). The PC algorithm is based on the principles of conditional independence and the causal Markov assumption, which allows it to efficiently identify causal relationships among variables in a given dataset. The algorithm first starts with a fully connected undirected graph among all the variables. Then it removes the edge between two variables if there is an unconditional or conditional independence relationship between them. Afterwards, it orients the directed edges whenever there is a V-structure. And finally, it iteratively checks the direction of the other edges until the entire causal graph is consistent with all the statistical correlations.

Dataset Construction

We introduce the construction of our dataset in this section. We start with our task formulation for Corr2Cause, and then briefly give an overview of the data generation process, followed by detailed descriptions of each step. We conclude the section with the overall statistics of the dataset.

Given a set of $N$ variables $\bm{X}=\{X_{1},\dots,X_{N}\}$, we have a statement $\bm{s}$ about all the correlations among the variables, and a hypothesis $\bm{h}$ describing the causal relation $r$ between the pair of variables $X_{i}$ and $X_{j}$. The task is to learn a function $f:(\bm{s},\bm{h})\mapsto v$ which maps the correlation statement $\bm{s}$ and the causal relation hypothesis $\bm{h}$ to their validity $v\in\{0,1\}$, which takes the value 0 if this inference is invalid, and the value 1 if this inference is valid.

2 Overview of the Data Generation Process

We base the construction our dataset on several concepts of causal inference, including the DGCM, d-separation, and MECs, as introduced in Section 2.

As in the overview of our data generation process in Figure 2, we first choose the number $N$ of variables (Step 1) and generate all the unique DGCMs with $N$ nodes (Step 2), which we will introduce in the Section 3.3. Then we collect all the d-separation sets from these graphs to identify MECs (Step 3) in Section 3.4. Then, in Step 4, we create the formal form of data in Section 3.5. For each correspondence of the MEC to causal graphs, we compose the correlation statement based on the statistical relations in the MEC, and hypothesize a causal relation between two variables, and produce the validity $v=1$ if the hypothesis is a shared property of all causal graphs in the MEC, and $v=0$ if the hypothesis is not necessarily true for all the MEC graphs. Finally, we introduce the verbalization process in Section 3.6.

3 Constructing the Graphs with Isomorphism Checks

The first step of the data generation is to compose the causal graphs, as in Step 1 and 2 of Figure 2. For a set of $N$ variables $\bm{X}=\{X_{1},\dots,X_{N}\}$, there are $N(N-1)$ possible directed edges, since each node can link to any node other than itself. To remove cycles in the graph, we make the nodes in topological order, which only allows edges $X_{i}\rightarrow X_{j}$, where $i<j$. We achieve this by limiting the adjacency matrix of the graph to only having non-zero values above the diagonal, resulting in $N(N-1)/2$ possible directed edges for the DAGs.

At the first glance, for $N$ nodes, there should be $2^{N(N-1)/2}$ possible DAGs (i.e., the power set of all edges). However, there could be isomorphic graphs in this set. To avoid this, we perform a graph isomorphism check (McKay & Piperno, 2014), and reduce the set so that only unique DAGs are retained, and we show their statistics in Table 1. Although we can handle large graphs, we mostly focus on smaller graphs that can still lead to a reasonably sized dataset, so we empirically set $N=6$, but future work can use our open-sourced codes to extend to more nodes.

4 Programmatically Generating the D-Separation Sets

Based on the set of unique DAGs, we then programmatically generate the d-separation sets by graph theoretical conditions, as in Step 3 of Figure 2. To realize this step, we code an efficient graph-theoretic algorithm to check for all the chain, fork, and collider structures to automatically identify the set of nodes that d-separate each pair of nodes. Using the d-separation sets and the faithfulness assumption, we form the statistical correlations as follows. For each pair of nodes, they are conditionally independent given the variables in the d-separation set. If the d-separation set is empty, then the two nodes are unconditionally independent. If no d-separation set can be found for the two nodes, then they are directly correlated.

Moreover, using the d-separation sets, we are able to cluster causal graphs to MECs. We achieve it by tracing the mapping between the causal graphs and the set of statistical correlations, and backtracking the graphs with the same d-separation sets to group them in the same MEC. We show in Table 1 that each MEC contains on average 2.66 DAGs.

5 Composing the Hypotheses and Label

After generating the set of correlations based on the d-separation sets, we now generate the causal hypotheses. For the causal relation $r$, we focus on six common causal relations between two nodes introduced in Section 2.1: Is-Parent, Is-Child, Is-Ancestor (excluding the parents), Is-Descendant (excluding the children), Has-Confounder (i.e., there exists a confounder, or common cause, of the two nodes), and Has-Collider (i.e., there exists a collider, or common effect, of the two nodes). In this way, the set of hypotheses contains all six meaningful causal relations between every pair of variables, resulting in a total size of $6\cdot N(N-1)/2=3N(N-1)$ hypotheses for a graph with $N$ variables.

To generate the ground-truth validity label, we start from the correlation sets in Step 3, then look up all the causal graphs in the same MEC corresponding to the given set of correlations, and check the necessity of the hypothesized causal relation. If the causal relationship proposed in the hypothesis is valid for all causal graphs within the MEC, then we generate the validity $v=1$; otherwise, we generate $v=0$. A special case of valid samples is that when the size of the MEC is 1, then there is a bijective mapping between the causal graph and the d-separation sets, so any hypothesis stating the causal properties of that unique causal graph is valid.

6 Verbalizing into Language

Finally, as in the last step of Figure 2, we convert all the information above to text data for our Corr2Cause task. For the correlation statement, we verbalize the set of correlations in Step 3 into a natural language statement $\bm{s}$. When two variables cannot be d-separated, i.e., $A\not\perp\!\!\!\perp B$, then we describe them as “$A$ correlates with $B$” since they are directly correlated and cannot be independent by any condition. And if two variables have a valid d-separation set $\bm{C}$, then we describe them as “$A$ is independent of $B$ given $\bm{C}$.” In the special case when the d-separation set is empty, we directly say “$A$ is independent of $B$.” In addition, we disambiguate the setting by starting the correlation statement with the setup of a closed system of the given variables, and no hidden variables: “Suppose there is a closed system of $N$ variables, A, B, … All the statistical relations among these $N$ variables are as follows:”. Finally, to verbalize the hypothesis, we feed the causal relation triplet ($X_{i}$, $r$, $X_{j}$) into their hypothesis templates in Table 2. For example, we turn the triplet ($A,\text{Is-Parent},B$) into “$A$ directly causes $B$”, as in the example of Figure 2.

7 Statistics of the Resulting Data

We show the statistics of our Corr2Cause dataset in Table 3. Overall, our dataset contains 207,972 samples, where 18.57% of the samples have the positive label (i.e., with validity=1). The average length of the premise is 424.11 tokens, and hypothesis 10.83 tokens. We split the data into 205,734 training samples, 1,076 development and 1,162 test samples. Since the main purpose of the dataset is to benchmark the performance of LLMs, we prioritize the test and development sets to have a comprehensive coverage over all sizes of graphs. Specifically, we iterate through the subset of our data for each $N$, and split it entirely for only the test and development sets if the data is less than 1K, which is the case for $N=2$ and $3$. For the other subsets that are larger, we randomly sample up to 1K or 10% of the data, whichever is smaller, to the test and development sets. We set the cap to be 1K in order to form a reasonable computation budget, since many LLMs are expensive to query in the inference mode. Aside from the test and valid sets, all the rest of the data goes into the training set.

Note for our dataset v2.0: We notice that our original dataset (v1.0) has duplication due to symmetric relations and verbalizations of the hypothesis. E.g., Is-Parent(A, B) has the exact hypothesis verbalization as Is-Child(B, A). Hence, for our dataset v2.0, we perform a careful de-duplication, and update the data statistics in Table 3. See more version comparison details in Appendix D. Note that, due to the symmetry, the current version is a random sample half of the size of the original version, so the modeling results in the experiment section roughly hold.

Experiments

We set up a diverse list of LLMs for the experiments on our Corr2Cause dataset. To test existing LLMs, we first include six commonly used BERT-based NLI models in the transformers library (Wolf et al., 2020) with the most number of downloads: BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), BART (Lewis et al., 2020), DeBERTa (He et al., 2021), DistilBERT (Sanh et al., 2019), and DistilBART (Shleifer & Rush, 2020). Apart from these BERT-based NLI models, we also evaluate the general-purpose autoregressive LLMs based on GPT (Radford et al., 2019): GPT-3 Ada, Babbage, Curie, Davinci (Brown et al., 2020); its instruction-tuned versions (Ouyang et al., 2022), text-davinci-001, text-davinci-002, and text-davinci-003; and GPT-3.5 (i.e., ChatGPT), and the latest GPT-4 (OpenAI, 2023) by April 2023, using the OpenAI APIhttps://openai.com/api/ with temperature 0. We also evaluate the recent, more efficient models, LLaMa (Touvron et al., 2023) and Alpaca (Taori et al., 2023).

When inspecting the behavior of finetuned models, we adopt a large set of models, including GPT-based models (GPT-3 Ada, Babbage, Curie, and Davinci) using the OpenAI finetuning API for classification,https://platform.openai.com/docs/guides/fine-tuning open-sourced decoder-only models (GPT2, GPT2-Large, GPT2-XL, LLaMA-7B, and LLaMa2-7B), BERT-based models from scratch (BERT-Base, BERT-Large, RoBERTa-Base, and RoBERTa-Large), and BERT-Based NLI models (BERT-Base MNLI, BERT-Large MNLI, RoBERTa-Base MNLI, and RoBERTa-Large MNLI) using the transformers library (Wolf et al., 2020). Our training details are available in Appendix A.

For the random baselines, we provide “always majority” to predict the majority class 100% of the time, “random (uniform)” which randomly samples a label with 50% chance for each, and “random (proportional)” which samples a label from a Bernouli distribution proportional to the development set label distribution.

2 The Corr2Cause Skill in Existing LLMs

We show the performance of 17 LLMs in Table 4. We can see that pure causal inference is a very challenging task across all existing LLMs. Among all the LLMs, the best performance is 33.38% F1 by BART MNLI, which is even higher than latest GPT-based model, GPT-4. Notably, many models are worse than random guess, which means that they totally fail at this pure causal inference task.

3 Finetuned Performance

Next, we address the question: Can we re-purpose LLMs to learn this task?

The experimental results in Table 5(a) of 17 models finetuned on our Corr2Cause seem very strong at first sight. Most models see a substantial increase, among which the finetuned BERT-based NLI models demonstrate the strongest performance. The best-performing one, RoBERTa-Large MNLI, achieves 94.74% F1 score on this task, as well as very high precision, recall and accuracy scores.

4 Fine-Grained Performance by Causal Relation

In addition to the overall results mentioned above, we also conduct a fine-grained analyze to check the performance of the strongest model, RoBERTa-Large MNLI, by our six causal relation types. As in Table 6(a), the model is very good at judging relations such as Is-Parent, Is-Descendant and Has-Confounder, all with more than 96% F1 scores, whereas it is several points weaker on the Has-Collider relations. This could be due to that the collider relation is the most special type, requiring identification of the V-structure based on both the unconditional independence based on the two variables only and correlations whenever conditioned on a common descendant.

5 Robustness Analysis

Looking at the very high performance of the finetuned models, we raise the next question: Did the models really robustly learn the causal inference skills?

We design two simple robustness tests: (1) paraphrasing, and (2) variable refactorization. For (1) paraphrasing, we simply paraphrase the hypothesis by changing the text template for each causal relation to some semantically-equivalent alternatives in Appendix C. For (2) variable refactorization, we reverse the alphabet of the variable names, namely flipping A, B, C, to Z, Y, X and so on. The inspiration behind the two robustness tests comes from the spurious correlation analysis described in Appendix E.

Specifically, we adopt the common setup of text adversarial attack (Morris et al., 2020; Jin et al., 2020) to preserve the training set and keep the same saved models, but run the inference n the perturbed test set. In this way, we separate the possibilities of the models only overfitting on the training data vs. mastering the reasoning skills.

Results after Perturbation

We can see from Table 5(b) that all the models drop drastically, by up to 39.29 when we paraphrase the test set, and they decrease substantially by up to 62.3 when we refactor the variable names. The best-performing model, RoBERTa-Large MNLI, is especially sensitive towards paraphrasing, demonstrating the most drop among all models; however, it is the most robust against the variable refactorization, maintaining a high F1 score of 67.87. We conduct fine-grained analysis for RoBERTa-Large MNLI under perturbation in Table 6(b). We can see the the main source of the performance drop of the model comes from the two classes, Is-Ancestor (decreasing to 45.45%) and Is-Descendant (decreasing to 29.41%), while the other classes stay relatively robust, keeping their F1 scores over 70%.

From this analysis, we make the following suggestions to future studies testing this Corr2Cause skill of LLMs. First, it is safe to use it as a test set to benchmark existing LLMs’ performance, since the data we generate is out-of-distribution from the training data of the current LLMs. Then, when testing finetuned models, it is very important to accompany adversarial attack together with the i.i.d. test set. We also provide our perturbed versions of the test set in our data for future work to test the generalizability skill.

6 Extension to Natural Stories

We envision our Corr2Cause dataset to be a foundation for future extensions to various settings, such as instantiating the variables with actual phenomena and situating the story in a more natural setting. For example, the correlation does not imply causation rule can be instantiated with the ice cream sales and swimming pool attendance as the two variables, and argue that ice cream sales does not necessarily affect swimming pool attendance, because their correlation could be due to a third variable, such as hot weather. We provide a case study for how to instantiate the symbolic expressions in our dataset to more natural stories, and find that LLMs such as GPT-4 can generate realistic, daily life stories that has foreseeably broad applications. See more details in Appendix B.

Related Work

A large body of existing research of causal reasoning in NLP focuses on leveraging empirical knowledge to do tasks such as inferring the cause and effect of why an agent perform certain tasks (Sap et al., 2019a), the motivation and emotional reaction in a social context (Sap et al., 2019b), how people achieve a given goal with a set of concrete steps (Zhang et al., 2020), the development of a story given a different beginning (Qin et al., 2019), and how in general LLMs serve as a knowledge base of cause and effect (Willig et al., 2023; Kıcıman et al., 2023). In contrast, our Corr2Cause task focuses on the pure causal inference skill of models, which is a knowledge-dependent reasoning skill based on formally correct rules from causal inference.

Existing Logical and Inference Tasks

Another related area of literature is logical and inference tasks. A well-established task is natural language inference (NLI), which identifies the semantic relationship between a pair of sentences (MacCartney & Manning, 2008; Bowman et al., 2015). NLI datasets mainly focus on the set and paraphrase relations, such as “a group of boys are playing football” can entail “some guys are playing football,” where “boys” are a sub-concept of “guys” and “a group of” and “some” are paraphrases. Existing datasets cover entailment in news articles (Dagan et al., 2006), image captions (Bowman et al., 2015), and across multiple genres (Williams et al., 2018). Recently, there has been increasing efforts to extend the inference task to various logical inference skills such as deductive logic and propaganda techniques (Jin et al., 2022; Alhindi et al., 2022). Our Corr2Cause dataset is the first dataset testing the correlation-to-causation inference skill, which is unique of its type.

Limitations and Future Work

We identify several limitations of this work and open future directions: First, in the context of this work, we limit the causal graphs to two to six nodes, but future work can feel free to explore larger graphs. Another aspect is that we do not assume hidden confounders in this inference problem, so we welcome future work to generate an even more challenging dataset to infer the existence of hidden confounders, analogous to the causal discovery algorithm of fast causal inference (FCI) (Spirtes et al., 2000). And also in general, explorations of other causal discovery algorithms are welcomed too. Finally, a lot of motivation behind proposing this task is inspired by the problem of invalid reasoning patterns in our daily reasoning (Jin et al., 2022), which could fertilize the ground for more pervasive spread of fake news. We believe false causal inference is a prevalent type of fallacious beliefs, and welcome future work to connect the idea of this benchmark to more real-world false beliefs based on confusing correlation with causation.

Conclusion

In this work, we introduced a novel task, Corr2Cause, to infer causation from correlation, and collected a large-scale dataset of over 200K samples. We evaluated an extensive list of LLMs on this new task, and showed that off-the-shelf LLMs perform poorly on this task. We also show that it is possible to re-purpose LLMs on this task by finetuning, but future work needs to be aware of the out-of-distribution generalization problem. To avoid the Goodhart’s law, we recommend using this dataset to benchmark the pure causal inference skills for LLMs that have not seen this dataset. Given the limited reasoning abilities of current LLMs, and the difficulty of separating actual reasoning from training-corpus-derived knowledge, it is imperative that our community focus on work aiming to accurately disentangle and measure both abilities. We believe that the present work is a first such step.

References

Appendix A Implementation Details

When finetuning on our data, for GPT-based models, we use the default settings of the OpenAI finetuning API; and for BERT-based models, we use the transformers library (Wolf et al., 2020) and train the models on a server with an NVIDIA Tesla A100 GPU with 40G of memory. To fit for the GPU memory, we set the batch size to be 8. We use the validation set to tune the learning rate, which takes value in {2e-6, 5e-6, 1e-5, 2e-5, 5e-5}; dropout rate, which takes value in {0, 0.1, 0.2, 0.3}; and weight decay, which takes value in {1e-4, 1e-5}. We train the models until convergence, which is usually around ten epochs.

When querying the autoregressive LLMs, we formulate the prompt as follows:

Can we deduct the following: [hypothesis]? Just answer "Yes" or "No."

Appendix B Generating Natural Stories

To generate the natural stories based on our symbolic expressions, we utilize the state-of-the-art LLM, GPT-4, which is very good at story generation. We design detailed instructions in the prompt, and generate around 200 stories in our case study. We show two examples stories in Table 7, and the report the overall statistics in Table 8.

For more information, the exact prompt we use is “Here is a causal inference rule: [symbolic form] Please provide a real-world example instantiating this phenomenon. Format it also as "Premise:", "Hypothesis:", and "Relation between the promise and hypothesis:".”

Appendix C Templates and Paraphrases

We use the verbalization templates in Table 9 to compose the hypotheses for all six causal relations.

Appendix D Change Log for the Dataset Version Update

As mentioned in Section 3.7 in the main paper, our original dataset (v1.0) has duplication due to symmetric relations and verbalizations. We introduce in Table 10 several reasons for why duplicated hypotheses exist in our original data. One typical reason is symmetric relations such as Is-Parent(A, B) and Is-Child(B, A), and, similarly, the paraphrased version of Is-Ancestor(A, B) and Is-Descendent(B, A). Another typical reason is the semantic equivalence in the verbalization templates, which applies to the Has-Collider and Has-Confounder relations. For example, the verbalized texts of Has-Collider(A, B) and Collider(B, A) are “There exists at least one collider (i.e., common effect) of {A and B, B and A},” respectively, which are semantically-equivalent paraphrases of each other, so we randomly keep one out of the two.

Resulting Dataset Statistics after De-Duplication

Since the reason for duplication in the first place is due to symmetry in the causal relation, or verbalization, the resulting new data, Corr2Cause v2.0, is exactly a half of the original data. As we reported previously in Table 3 of Section 3.7, the total number of samples cuts down to half, while the label distribution and all other properties are the same. To compose each split, we apply the same de-duplication method for the test, train, and development sets. We notice that some duplicates are across the splits, so we prioritize keeping the test and training sets untouched (to minimally affect the experimental results), and then reduce the development set by removing the cross-split duplicates, namely:

dev_2.0 = deduplicate(dev_1.0) $\backslash$ {test_2.0, train_2.0}

We expect minimal or almost no change to the experimental results. In case of the slight possibility that this change in the development set might affect the model selection in the training process, future work can feel free to re-train the models and update the exact performance number.

Appendix E Spurious Correlation Analysis

The inspirations of our two robustness tests (paraphrasing and variable refactorization) come from our data analysis. We check for spurious correlations in the data by reporting in Table 11 the point-wise mutual information (PMI) between the label and any n-gram with no more than four tokens. In addition, we also report the difference of the PMI with the two labels in the $|\text{Diff}|$ column of Table 11, and report the top 10 n-grams.

The design spirit for our robustness test is that if the models’ correct judgment relies on exploiting these spurious correlations, then such reliance will be broken in our perturbations.

We can see that some spurious correlations are rooted in the framing of the hypothesis, such as “a cause (for)”, and “a direct (one)” (which we use the paraphrasing task to break), and others are connected to the variable names, such as “for D (but)” and “for E (but)” (which we use the variable refactorization to break).

Appendix F Fine-Grained Error Analysis

In addition to the fine-grained analysis by causal relation type in Table 6(a) for fine-tuned models, we also report such error analysis for non-finetuned models in Table 12.

These results are particularly revealing, showing how off-the-shelf models perform in recognizing specific relations. Specifically, GPT-3.5 cannot recognize ancestor relations, whereas GPT-4 fails at all direct causation recognition with parents and children. And RoBERTa MNLI only did collider relation relatively correctly. Note that, when the F1 score is zero, the accuracy number is a result of always predicting the negative class of that relation.