alignment-papers-text/2303.02536_Finding_Alignments_Between_Interpretable_Causal_Va.md

Proceedings of Machine Learning Research vol 236:1–23, 2024 3rd Conference on Causal Learning and Reasoning

## **Finding Alignments Between Interpretable** **Causal Variables and Distributed Neural Representations**


**Atticus Geiger** [˚] _[♢]_ **, Zhengxuan Wu** [*] **, Christopher Potts, Thomas Icard, and Noah D. Goodman**





**Pr(Ai)** [2] **R Group** _[♢]_ **Stanford University**

**{atticusg, wuzhengx, cgpotts, icard, ngoodman}@stanford.edu**





**Editors:** Francesco Locatello and Vanessa Didelez





**Abstract**





Causal abstraction is a promising theoretical framework for explainable artificial intelligence that

defines when an interpretable high-level causal model is a faithful simplification of a low-level deep

learning system. However, existing causal abstraction methods have two major limitations: they

require a brute-force search over alignments between the high-level model and the low-level one, and

they presuppose that variables in the high-level model will align with disjoint sets of neurons in the

low-level one. In this paper, we present _distributed alignment search_ (DAS), which overcomes these

limitations. In DAS, we find the alignment between high-level and low-level models using gradient

descent rather than conducting a brute-force search, and we allow individual neurons to play multiple

distinct roles by analyzing representations in non-standard bases— _distributed_ representations. Our

experiments show that DAS can discover internal structure that prior approaches miss. Overall, DAS

removes previous obstacles to uncovering conceptual structure in trained neural nets.



**1. Introduction**





Can an interpretable symbolic algorithm be used to faithfully explain a complex neural network

model? This is a key question for interpretability; a positive answer can provide guarantees about

how the model will behave, and a negative answer could lead to fundamental concerns about whether

the model will be safe and trustworthy.

Causal abstraction provides a mathematical framework for precisely characterizing what it means

for any complex causal system (e.g., a deep learning model) to implement a simpler causal system

(e.g., a symbolic algorithm) (Rubenstein et al., 2017; Beckers et al., 2019; Massidda et al., 2023).

For modern AI models, the fundamental operation for assessing whether this relationship holds in

practice has been the _interchange intervention_ (also known as activation patching), in which a neural

network is provided a ‘base’ input, and sets of neurons are forced to take on the values they would

have if different ‘source’ inputs were processed (Geiger et al., 2020; Vig et al., 2020; Finlayson et al.,

2021; Meng et al., 2022). The counterfactuals that these interventions create are the basis for causal

inferences about model behavior.



Geiger et al. (2021) show that the relevant causal abstraction relation obtains when interchange

interventions on aligned high-level variables and low-level variables have equivalent effects. This

ideal relationship rarely obtains in practice, but the proportion of interchange interventions with the

same effect ( _interchange intervention accuracy_ ; IIA) provides a graded notion, and Geiger et al.

(2023) formally ground this metric in the theory of approximate causal abstraction. Geiger et al. also

use causal abstraction theory as a unified framework for a wide range of recent intervention-based

analysis methods (Vig et al., 2020; Csordás et al., 2021; Feder et al., 2021; Ravfogel et al., 2020;





  - Equal contribution.





© 2024 .





Elazar et al., 2020; De Cao et al., 2021; Abraham et al., 2022; Olah et al., 2020; Olsson et al., 2022;

Chan et al., 2022).

Causal abstraction techniques have been applied to diverse problems (Geiger et al., 2019, 2020;

Li et al., 2021; Huang et al., 2022). However, previous applications have faced two central challenges.

First, causal abstraction requires a computationally intensive brute-force search process to find

optimal alignments between the variables in the high-level model and the states of the low-level one.

Where exhaustive search is intractable, we risk missing the best alignment entirely. Second, these

prior methods are _localist_ : they artificially limit the space of possible alignments by presupposing

that high-level causal variables will be aligned with disjoint groups of neurons. There is no reason to

assume this a priori, and indeed much recent work in model explanation (see especially Ravfogel

et al. 2020, 2022; Elazar et al. 2020; Olah et al. 2020; Olsson et al. 2022) is converging on the insight

of Smolensky (1986), Rumelhart et al. (1986), and McClelland et al. (1986) that individual neurons

can play multiple conceptual roles. Smolensky (1986) identified _distributed neural representations_

as “patterns” consisting of linear combinations of unit vectors.

In the current paper, we propose distributed alignment search (DAS), which overcomes the above

limitations of prior causal abstraction work. In DAS, we find the best alignment via _gradient descent_

rather than conducting a brute-force search. In addition, we use _distributed interchange interventions_,

which are “soft” interventions in which the causal mechanisms of a group of neurons are edited

such that (1) their values are rotated with a change-of-basis matrix, (2) the targeted dimensions

of the rotated neural representation are fixed to be the corresponding values in the rotated neural

representation created for the source inputs, and (3) the representation is rotated back to the standard

neuron-aligned basis. The key insight is that viewing a neural representation through an alternative

basis that is not aligned with individual neurons can reveal interpretable dimensions (Smolensky,

1986).

In our experiments, we evaluate the capabilities of DAS to provide faithful and interpretable

explanations with two tasks that have obvious interpretable high-level algorithmic solutions with two

intermediate variables. In both tasks, the distributed alignment learned by DAS is as good or better

than both the closest localist alignment and the best localist alignment in a brute-force search.

In our first set of experiments, we focus on a hierarchical equality task that has been used

extensively in developmental and cognitive psychology as a test of relational reasoning (Premack,

1983; Thompson et al., 1997; Geiger et al., 2022a): the inputs are sequences r _w,_ _x,_ _y,_ _z_ s, and the

label is given by p _w_ “ _x_ q “ p _y_ “ _z_ q. We train a simple feed-forward neural network on this task and

show that it perfectly solves the task. Our key question: does this model implement a program that

computes _w_ “ _x_ and _y_ “ _z_ as intermediate values, as we might hypothesize humans do? Using DAS,

we find a distributed alignment with 100% IIA. In other words, the network is perfectly abstracted by

the high-level model; the distinction between the learned neural model and the symbolic algorithm is

thus one of implementation.

Our second task models a natural language inference dataset (Geiger et al., 2020) where the

inputs are premise and hypothesis sentences p _p,_ _h_ q that are identical but for the words _wp_ and _wh_ ;

the label is either _entails_ ( _p_ makes _h_ true) or _contradicts_ / _neutral_ ( _p_ makes _h_ false). We fine-tune a

pretrained language model to perfectly solve the task. With DAS, we find a perfect alignment (100%

IIA) to a causal model with a binary variable for the entailment relation between the words _wp_ and

_wh_ (e.g., _dog_ entails _mammal_ ).

In both our sets of experiments, the DAS analyses reveal perfect abstraction relations. However,

we also identify an important difference between them. In the NLI case, the entailment relation can





2





FINDING DISTRIBUTED ALIGNMENTS





be decomposed into representations of _wp_ and _wh_ . What appears to be a representation of lexical

entailment is, in this case, a “data structure” containing two representations of word identity, rather

than an encoding of their entailment relation. By contrast, the hierarchical equality models learn

representations of _w_ “ _x_ and _y_ “ _z_ that cannot be decomposed into representations of _w_, _x_, _y_ and _z_ .

In other words, these relations are entirely abstracted from the entities participating in the relation;

DAS reveals that the neural network truly implements a symbolic, tree-structured algorithm.





**2. Related Work**





A theory of _causal abstraction_ specifies exactly when a ‘high-level causal model’ can be seen as

an abstract characterization of some ‘low-level causal model’ (Iwasaki and Simon, 1994; Chalupka

et al., 2017; Rubenstein et al., 2017; Beckers et al., 2019). The basic idea is that high-level variables

are associated with (potentially overlapping) sets of low-level variables that summarize their causal

mechanisms with respect to a set of hard or soft interventions (Massidda et al., 2023). In practice, a

graded notion of _approximate_ causal abstraction is often more useful (Beckers et al., 2019; Rischel

and Weichwald, 2021; Geiger et al., 2023).





Geiger et al. (2023) argue that causal abstraction is a generic theoretical framework for providing

_faithful_ (Jacovi and Goldberg, 2020; Lyu et al., 2022) and _interpretable_ (Lipton, 2018) explanations of

AI models and show that LIME (Ribeiro et al., 2016), causal effect estimation (Abraham et al., 2022;

Feder et al., 2021), causal mediation analysis (Vig et al., 2020; Csordás et al., 2021; De Cao et al.,

2021), iterated nullspace projection (Ravfogel et al., 2020; Elazar et al., 2020), and circuit-based

explanations (Olah et al., 2020; Olsson et al., 2022; Wang et al., 2022; Chan et al., 2022) can all be

understood as causal abstraction analysis.



Interchange intervention training (IIT) objectives are minimized when a high-level causal model

is an abstraction of a neural network under a given alignment (Geiger et al., 2022b; Wu et al., 2022;

Huang et al., 2022). In this paper, we use IIT objectives to learn an alignment between a high-level

causal model and a deep learning model.





**3. Methods**





We focus on acyclic causal models (Pearl, 2001; Spirtes et al., 2000) and seek to provide an intuitive

overview of our method. An **acyclic causal model** consists of input, intermediate, and output

**variables**, where each variable has an associated set of **values** it can take on and a **causal mechanism**

that determine the value of the variable based on the value of its causal parents. For a simple running

example, we modify the boolean conjunction models of Geiger et al. (2022b) to reveal key properties

of DAS. A causal model _B_ for this problem can be defined as below, where the inputs and outputs

are booleans T and F. Alongside _B_, we also define a causal model _N_ of a linear feed-forward neural

network that solves the task. Here we show _B_, _N_, and the parameters of _N_ :















_WW_ 21 “ “ ““ sincospp2020 [˝][˝] qq ´cossinpp2020 [˝][˝] qq ‰‰ **w** “ _b_ “ ´“ 11 _._ 81 ‰















The model _N_ predicts T if _O_ ą 0 and F otherwise. This network solves the boolean conjunction

problem perfectly in that all pairs of input boolean values are mapped to the intended output.

An input **x** of a model _M_ determines a unique total setting _M_ p **x** q of all the variables in the

model. The inputs are fixed to be **x** and the causal mechanisms of the model determine the values of





3





the remaining variables. We denote the values that _M_ p **x** q assigns to the variable or variables **Z** as

GETVALUES **Z** p _M_ p **x** qq. For example, GETVALUES _V_ 3p _B_ prT _,_ Fsqq “ F.



**3.1. Interventions**





Interventions are a fundamental building block of causal models, and of causal abstraction analysis

in particular. An intervention **I** Ð **i** is a setting **i** of variables **I** . Together, an intervention and an input

setting **x** of a model _M_ determine a unique total setting that we denote as _M_ **I** Ð **i** p **x** q. The inputs are

fixed to be **x**, and the causal mechanisms of the model determine the values of the non-intervened

variables, with the intervened variables **I** being fixed to **i** .

We can define interventions on both our causal model _B_ and our neural model _N_ . For example,

_BV_ 1ÐTprF _,_ Tsq is our boolean model when it processes input rF _,_ Ts but with variable _V_ 1 set to T. This

has the effect of changing the output value to T. Similarly, whereas _N_ pr0 _,_ 1sq leads to an intermediate

values _h_ 1 “ ´0 _._ 34 and _h_ 2 “ 0 _._ 94 and output value ´1 _._ 2, if we compute _Nh_ 1Ð1 _._ 34pr0 _,_ 1sq, then the

output value is 0 _._ 48. This has the effect of changing the predicted value to T, because 0 _._ 48 ą 0.





**3.2. Alignment**



In causal abstraction analysis, we ask whether a specific low-level model like _N_ implements a

high-level algorithm like _B_ . This is always relative to a specific _alignment_ of variables between

the two models. An alignment Π “ ptΠ _X_ u _X_ _,_ t _τX_ u _X_ q assigns to each high-level variable _X_ a set of

low-level variables Π _X_ and a function _τX_ that maps from values of the low-level variables in Π _X_ to

values of the aligned high-level variable _X_ . One possible alignment between _B_ and _N_ is shown in

the diagram above: Π is depicted by the dashed lines connecting _B_ and _N_ .

We immediately know what the functions for high-level input and output variables are. For the

inputs, T is encoded as 1 and F is encoded as 0, meaning _τP_ p1q “ _τQ_ p1q “ T and _τP_ p0q “ _τQ_ p0q “ F.

For the output, the network only predicts T if _y_ ą 0, meaning _τV_ 3p _x_ q “ T if _x_ ą 0, else F. This is

simply a consequence of how a neural network is used and trained. The functions for high-level

intermediate variables _τV_ 1p _x_ q and _τV_ 2p _x_ q must be discovered and verified experimentally.



**3.3. Constructive Causal Abstraction**





Relative to an alignment like this, we can define abstraction:





**Definition 1** (Constructive Causal Abstraction) _A high-level causal model H is a constructive_

_abstraction of a low-level causal model L under alignment_ Π _exactly when the following holds for_

_every low-level input setting_ **x** _and low-level intervention_ **I** Ð **i** _:_





_τ_ p _L_ **I** Ð **i** p **x** q˘ “ _Hτ_ p **I** Ð **i** qp _τ_ p **x** qq





_H_ being a causal abstraction of _L_ under Π guarantees that the causal mechanism for each high-level

variable _X_ is a faithful rendering of the causal mechanisms for the low-level variables in Π _X_ .

To assess the degree to which a high-level model is a constructive causal abstraction of a low-level

model, we perform interchange interventions:





**Definition 2** (Interchange Interventions) _Given source input settings_ t **s** _j_ u _[k]_ 1 _[, and non-overlapping]_

_sets of intermediate variables_ t **X** _j_ u _[k]_ 1 _[for model][ M][, define the interchange intervention as the model]_





IIp _M,_ t **s** _j_ u _[k]_ 1 _[,]_ [t] **[X]** _[ j]_ [u] _[k]_ 1 [q “] _[ M]_ [Ź] _[k]_

_j_ “1 [x] **[X]** _[j]_ [Ð][GetVals] **[X]** _j_ [p] _[M]_ [ p] _[s]_ _[j]_ [qqy]





_where_ [Ź] _[k]_ _j_ “1 [x¨y] _[ concatenates a set of interventions.]_





4





FINDING DISTRIBUTED ALIGNMENTS





A _base_ input setting can be fed into the resulting model to compute the counterfactual output value.

Consider the following interchange intervention:





IIp _B,_ trT _,_ Tsu _,_ tt _V_ 1uuq “ _B_ t _V_ 1uÐGetValst _V_ 1up _B_ prT _,_ Tsqq





We process a base input and a source input, and then we intervene on a target variable, replacing it

with the value obtained by processing the source. Our causal model is fully known, and so we know

ahead of time that this interchange intervention yields T. For our neural network, the corresponding

behavior is not known ahead of time. The interchange intervention corresponding to the above

(according to the alignment we are exploring) is as follows





IIp _N,_ tr1 _,_ 1su _,_ tt _H_ 1uuq “ _N_ t _V_ 1u Ð GetValst _H_ 1up _N_ pr1 _,_ 1sqq





And, indeed, the counterfactual behavior of the model and the network _N_ are unequal:



















F





|V3 “ T V3 “ T<br>V1 “ T V2 “ T V1 “ T V2 “ T<br>F T T T|Col2|Col3|

|---|---|---|

|_V_1 “ T|_V_2 “ T|_V_2 “ T|

||||

|F|T|T|





|O “ ´0.26 O “ 0.08<br>H1 “ 0.6 H2 “ 0.94 H1 “ 0.6 H2 “ 1.28<br>0 1 1 1|Col2|Col3|

|---|---|---|

|_H_1 “ 0_._6|_H_2 “ 1_._28|_H_2 “ 1_._28|

||||

|0|1|1|







Under the given alignment, the interchange interventions at the low and high level have different

effects. Thus, we have a counterexample to constructive abstraction as given in Definition 1.

Although _N_ has perfect behavioral accuracy, its accuracy under the counterfactuals created by our

interventions is not perfect, and thus _B_ is not a constructive abstraction of _N_ under this alignment.





**3.4. Distributed Interventions**





The above conclusion is based on the kind of localist causal abstraction explored in the literature to

date. As noted in Section 1, there are two risks associated with this conclusion: (1) we may have

chosen a suboptimal alignment, and (2) we may be wrong to assume that the relevant structure will

be encoded in the standard basis we have implicitly assumed throughout.

If we simply rotate the representation r _H_ 1 _,_ _H_ 2s by ´20 [˝] to get a new representation r _Y_ 1 _,Y_ 2s, then

the resulting network has perfect behavioral and counterfactual accuracy when we align _V_ 1 and _V_ 2

with _Y_ 1 and _Y_ 2. What this reveals is that there is an alignment, but not in the basis we chose. Since

the choice of basis was arbitrary, our negative conclusion about the causal abstraction relation was

spurious.

This rotation localizes the information about the first and second argument into separate dimensions. To understand this, observe that the weight matrix of the linear network rotates a two

dimensional vector by 20 [˝] and the rotation matrix rotates the representation by 340 [˝] . The two

matrices are inverses. Because this network is linear, there is no activation function and so rotating

the hidden representation “undoes” the transformation of the input by the weight matrix. Under this

non-standard basis, the first hidden dimension is equal to the first input argument and the second

hidden dimension is equal to the second input argument.

This reveals an essential aspect of distributed neural representations: there is a many-to-many

mapping between neurons and concepts, and thus multiple high-level causal variables might be

encoded in structures from overlapping groups of neurons (Rumelhart et al., 1986; McClelland et al.,

1986). In particular, Smolensky (1986) proposes that viewing a neural representation under a basis





5





**Y** 2































































Figure 1: A generic multi-source distributed interchange intervention. The base input and two source

inputs create three total settings of a model. The top left (green) and right (blue) total

model settings are determined by two source inputs and the middle total model setting

(red) is determined by the base input. Three hidden units from each total setting are rotated

with an orthogonal matrix **R** : **X** Ñ **Y** . Then we intervene on the rotated representation for

the base input and fix two dimensions to be the value they take on for each source input,

respectively. Then we unrotate the representation with **R** [´][1] and compute a counterfactual

total model setting for the base input. In DAS, the orthogonal matrix is found with gradient

descent using a high-level causal model to guide the search process.





that is not aligned with individual neurons can reveal the interpretable distributed structure of the

neural representations.



To make good on this intuition we define a distributed intervention, which first transforms a set

of variables to a vector space, then does interchange on orthogonal sub-spaces, before transforming

back to the original representation space.





**Definition 3** Distributed Interchange Interventions _We begin with a causal model M with input_

_variables_ **S** _and source input settings_ t **s** _j_ u _[k]_ _j_ “1 _[. Let]_ **[ N]** _[ be a subset of variables in][ M][, the]_ [ target]

variables _. Let_ **Y** _be a vector space with subspaces_ t **Y** _j_ u _[k]_ 0 _[that form an orthogonal decomposition, i.e.,]_

**Y** “ [À] _[k]_ _j_ “0 **[Y]** _[j][. Let]_ **[ R]** _[ be an invertible function]_ **[ R]** [ :] **[ N]** [ Ñ] **[ Y]** _[. Write]_ [ Proj] **Y** _j_ _[for the orthogonal projection]_

_operator of a vector in_ **Y** _onto subspace_ **Y** _j._ [1] _A_ _**distributed interchange intervention**_ _yields a new_

_model_ DIIp _M,_ **R** _,_ t **s** _j_ u _[k]_ 1 _[,]_ [t] **[Y]** _[j]_ [u] _[k]_ 0 [q] _[ which is identical to][ M][ except that the mechanisms][ F]_ **[N]** _[ (which yield]_





1. Thus, Proj generalizes GetVals to arbitrary vector spaces.





6





FINDING DISTRIBUTED ALIGNMENTS





_values of_ **N** _from a total setting) are replaced by:_







ˆ



´

` ˘ [¯]

_F_ **N** [˚][p] **[v]** [q “] **[ R]** [´][1] Proj **Y** 0 **R** _F_ **N** p **v** q `







ÿ _k_ ´ ` ˘ [¯˙]



Proj **Y** _j_ **R** _F_ **N** p _M_ p **sj** qq _._

_j_ “1







Notice that in this definition the base setting is partially preserved through the intervention (in

subspace **Y** 0) and hence this is a _soft_ intervention on **N** that rewrites causal mechanisms while

maintaining a causal dependence between parent and child.

Under this new alignment, the high-level interchange intervention IIp _B,_ trT _,_ Tsu _,_ tt _V_ 1uuq “

_B_ t _V_ 1uÐGetValst _V_ 1up _B_ prT _,_ Tsqq is aligned with the low-level distributed interchange intervention







ff





_,_ tr1 _,_ 1su _,_ tt _Y_ 1uuq







DIIp _N,_







«

cosp´20 [˝] q ´ sinp´20 [˝] q

sinp´20 [˝] q cosp´20 [˝] q







and the counterfactual output behavior of _B_ and _N_ are equal:





T







ff











«

cosp20 [˝] q ´ sinp20 [˝] q





|Col1|Col2|O “ 0.08|Col4|Col5|

|---|---|---|---|---|

||_H_1 “ 0_._6|_H_1 “ 0_._6|_H_2 “ 1_._28||















_O_ “ 0 _._ 08

















|Col1|H1 “ ´0.34|H2 “ 0.94|Col4|

|---|---|---|---|

||0|1|1|





|Col1|H1 “ 0.6|Col3|H2 “ 1.28|Col5|

|---|---|---|---|---|

||1||1||







In what follows we will assume that **X** are already vector spaces (which is true for neural nets)

and the functions **R** are rotation operators. In this case, the subspaces **Y** _j_ can be identified without

loss of generality with those spanned by the first | **Y** 0| basis vectors for **Y** 0, the next | **Y** 1| basis vectors

for **Y** 1, and so on. (The following methods would be well-defined for non-linear transformations, as

long as they were invertible and differentiable, but efficient implementation becomes harder.)





**3.5. Distributed Alignment Search**





The question then arises of how to find good rotations. As we discussed above, previous causal

abstraction analyses of neural networks have performed brute-force search through a discrete space

of hand-picked alignments. In distributed alignment search (DAS), we find an alignment between one

or more high-level variables and disjoint sub-spaces (but not necessarily subsets) of a large neural

representation. We define a distributed interchange intervention training objective, use differentiable

parameterizations for the space of orthogonal matrices (such as provided by PyTorch), and then

optimize the objective with stochastic gradient descent. Crucially, the low-level and high-level

models are frozen during learning so we are only changing the alignment.

In the following definition we assume that a neural network specifies an output _distribution_ for a

given input, which can then be pushed forward to a distribution on output values of the high-level

model via an alignment function _τ_ . We may similarly interpret even a deterministic high-level

model as defining a (e.g., delta) distribution on output values. We make use of these distributions,

after interchange intervention, to define a differentiable loss for the rotation matrix which aligns

intermediate variables.





**Definition 4** Distributed Interchange Intervention Training Objective _Begin with a low-level neural_

_network L, with low-level input settings_ **Inputs** _L, a high-level algorithm H, with high-level output_





7





_settings_ **Out** _H, and an alignment τ for their input and output variables. Suppose we want to align_

_intermediate high level variables X_ _j_ P **Vars** _H with rotated subspaces_ **Y** _j of a neural representation_

**N** Ă **Vars** _L with learned rotation matrix_ **R** _[θ]_ : **N** Ñ **Y** _._

_In general, we can define a training objective using any differentiable loss function_ Loss _that_

_quantifies the distance between two total high-level settings._





ˆ ˙





ÿ



Loss DIIp _L,_ **R** _[θ]_ _,_ t **s** _j_ u _[k]_ 1 _[,]_ [t] **[Y]** _[ j]_ [u] _[k]_ 0 [qp] **[b]** [q] _[,]_ [II][p] _[H][,]_ [t] _[τ]_ [p] **[s]** _[j]_ [qu] _[k]_ 1 _[,]_ [t] **[X]** _[ j]_ [u] _[k]_ 1 [qp] _[τ]_ [p] **[b]** [qq]

**b** _,_ **s** 1 _,...,_ **s** _k_ P **Inputs** _L_





_For our experiments, we compute the cross entropy loss_ CEp¨ _,_ ¨q _between the high-level output_

_distribution_ Pp **out** _H_ | _H_ p _τ_ p **b** qqq _and the push-forward under τ of the low-level output distribution_

P _[τ]_ p **out** _H_ | _L_ p **b** qq _. The overall objective is:_





ˆ ˙





ÿ



CE Pp **out** _H_ |IIp _H,_ t _τ_ p **s** _j_ qu _[k]_ 1 _[,]_ [t] **[X]** _[ j]_ [u] _[k]_ 1 [qqp] _[τ]_ [p] **[b]** [qq] _[,]_ [P] _[τ]_ [p] **[out]** _[H]_ [|][DII][p] _[L][,]_ **[R]** _[θ]_ _[,]_ [t] **[s]** _[j]_ [u] _[k]_ 1 _[,]_ [t] **[Y]** _[j]_ [u] _[k]_ 0 [qp] **[b]** [qq]

**b** _,_ **s** 1 _,...,_ **s** _k_ P **Inputs** _L_





While we still have discrete hyperparameters p **N** _,_ | **Y** 0| _,...,_ | **Y** _k_ |q—the target population and the

dimensionality of the sub-spaces used for each high-level variable—we may use stochastic gradient

descent to determine the rotation that minimizes loss, thus yielding the best distributed alignment

between _L_ and _H_ .





**3.6. Approximate Causal Abstraction**





Perfect causal abstraction relationships are unlikely to arise for neural networks trained to solve

complex empirical tasks. We use a graded notion of accuracy:





**Definition 5** Distributed Interchange Intervention Accuracy _Given low-level and high-level causal_

_models L and H with alignment_ pΠ _,_ _τ_ q _, rotation_ **R** : **N** Ñ **Y** _, and orthogonal decomposition_ t **Y** _j_ u _[k]_ 0 _[.]_

_If we let_ **Inputs** _L be low-level input settings and_ t **X** _j_ u _[k]_ 1 _[be high-level intermediate variables the]_

_**interchange intervention accuracy (IIA)**_ _is as follows_







ÿ





**b** _,_ **s** 1 _,...,_ **s** _k_ P **Inputs** _L_







1

| **Inputs** _L_ | _[k]_ [`][1]







” ı

_τ_ `DIIp _L,_ **R** _[θ]_ _,_ t **s** _j_ u _[k]_ 1 _[,]_ [t] **[Y]** _[ j]_ [u] _[k]_ 0 [qp] **[b]** [q] ˘ “ IIp _H,_ t _τ_ p **s** _j_ qu _[k]_ 1 _[,]_ [t] **[X]** _[ j]_ [u] _[k]_ 1 [qp] _[τ]_ [p] **[b]** [qq]







IIA is the proportion of aligned interchange interventions that have equivalent high-level and lowlevel effects. In our example with _N_ and _A_, IIA is 100% and the high-level model is a perfect

abstraction of the low-level model (Def. 1). When IIA is _α_ ă100%, we rely on the graded notion of

_α-on-average_ approximate causal abstraction (Geiger et al., 2023), which coincides with IIA.





**3.7. General Experimental Setup**





We illustrate the value of DAS by analyzing feed-forward networks trained on a hierarchical equality

and pretrained Transformer-based language models (Vaswani et al., 2017) fine-tuned on a natural

language inference task. Our evaluation paradigm is as follows:





1. Train the neural network _N_ to solve the task. In all experiments, the neural models achieve

perfect accuracy on both training and testing data.





2. Create interchange intervention training datasets using a high-level causal model. Each

example consists of a base input, one or more source inputs, high-level causal variables





8





FINDING DISTRIBUTED ALIGNMENTS





targetted for intervention, and a counterfactual gold label that will be output by the network

if the interchange intervention has the hypothesized effect on model behavior. This gold

label is a counterfactual output of the high-level model we will align with the network. (See

Appendix A.1 for details)





3. Optimize an orthogonal matrix to learn a distributed alignment for each high-level model that

maximizes IIA using the training objective in Def. 4. We experiment with different hidden

dimension sizes for our low-level model and different intervention site sizes (dimensionality of low-level subspaces) and locations (the layer where the intervention happens). (See

Appendix A.2 for details)





4. Evaluate a baseline that brute-force searches through a discrete space of alignments and selects

the alignment with the highest IIA. We search the space of alignments by aligning each highlevel variable with groups of neurons in disjoint sliding windows. (See Appendix A.3 for

details)





5. Evaluate the localist alignment “closest” to the learned distributed alignment. The rotation matrix for the localist alignment will be axis-aligned with the standard basis, possibly permuting

and reflecting unit axes. (See Appendix A.4 for details)





6. Determine whether each distributed representation aligned with high-level variables can be

decomposed into multiple representations that encode the identity of the input values to the

variable’s causal mechanism. We do this by learning a second rotation matrix that decomposes

learned distributed representation, holding the first rotation matrix fixed. (See Appendix A.5

for details)





The codebase used to run these experiments is at [2] . We have replicated the hierarchical equality

experiment using the Pyvene library at [3] .



**4. Hierarchical Equality Experiment**





We now illustrate the power of DAS for analyzing networks designed to solve a hierarchical equality

task. We concentrate on analyzing a trained feed-forward network.

A _basic_ equality task is to determine whether a pair of objects are the same ( _x_ “ _y_ ). A _hierarchical_

equality task is to determine whether a pair of pairs of objects have identical relations: p _w_ “ _x_ q “

p _y_ “ _z_ q. Specifically, the input to the task is two pairs of objects and the output is True if both pairs

are equal or both pairs are unequal and False otherwise. For example, p _A,_ _A,_ _B,_ _B_ q and p _A,_ _B,C,_ _D_ q

are both assigned True while p _A,_ _B,C,C_ q is assigned False.





**4.1. Low-Level Neural Model**





We train a three-layer feed-forward network with ReLU activations to perform the hierarchical

equality task. Each input object is represented by a randomly initialized vector. Specifically, our

model has the following architecture where _k_ is the number of layers.





_h_ 1 “ ReLUpr _x_ 1; _x_ 2; _x_ 3; _x_ 4s _W_ 1 ` _b_ 1q _h_ _j_ ´1 “ ReLUp _h_ _jWj_ ` _b_ _j_ q _y_ “ **softmax** p _hkWk_ ` _bk_ q





The input vectors are in R _[n]_, the biases are in R [4] _[n]_, and the weights are in R [4] _[n]_ [ˆ][4] _[n]_ . We evaluate our

model on held-out random vectors unseen during training, as in Geiger et al. 2022a.





[2. https://github.com/atticusg/InterchangeInterventions/tree/zen](https://github.com/atticusg/InterchangeInterventions/tree/zen)

[3. https://github.com/stanfordnlp/pyvene/blob/main/tutorials/advanced_tutorials/DAS_Main_](https://github.com/stanfordnlp/pyvene/blob/main/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb)

[Introduction.ipynb](https://github.com/stanfordnlp/pyvene/blob/main/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb)





9





Both Equality Relations Left Equality Relation Identity of First Argument Identity Subspace of

Left Equality





Hidden size Intervention size **Layer 1** **Layer 2** **Layer 3** **Layer 1** **Layer 2** **Layer 3** **Layer 1** **Layer 2** **Layer 3** **Layer 1**





| **N** | “ 16 1 0.88 0.51 0.50 0.85 0.54 0.50 0.51 0.52 0.50 0.51

| **N** | “ 16 2 0.97 0.54 0.50 0.85 0.55 0.50 0.50 0.52 0.51 0.50

| **N** | “ 16 8 1.00 0.57 0.50 0.90 0.56 0.50 0.52 0.53 0.51 0.51





| **N** | “ 32 2 0.93 0.63 0.49 0.92 0.65 0.50 0.52 0.55 0.52 0.50

| **N** | “ 32 4 0.97 0.63 0.49 0.94 0.65 0.50 0.51 0.55 0.52 0.51

| **N** | “ 32 16 0.99 0.67 0.53 0.99 0.65 0.50 0.49 0.55 0.52 0.51





Brute-Force Search 0.60 0.56 0.52 0.64 0.64 0.57 0.50 0.51 0.54    Localist Alignment 0.73 0.56 0.48 0.60 0.50 0.49 0.46 0.47 0.48    



Table 1: Hierarchical equality alignment learning results. The table can be read as follows: **Layer**

**1**, **Layer 2**, and **Layer 3** indicate which layer of neurons is targeted, | **N** | is the number

of neurons in a layer, _k_ is the number of neurons aligned with each intermediate variable

(red) where our subspace model occupies _[k]_



2 [with rounding up to the closest integer, and]

the values in each cell are interchange intervention accuracies for the learned alignment

on training data. We report the best results from three runs with distinct random seeds for

training the rotation matrix (the same frozen low-level model is used for each seed).





**4.2. High-Level Models**





We use DAS to evaluate whether trained neural networks have achieved the natural solution to the

hierarchical equality task where the left and right equality relations are computed and then used to

predict the final label (Figure 2).







However, evaluating this high-level model alone is

insufficient, as there are obviously many other high-level

models of this task. To further contextualize our results,

we also consider two alternatives: a high-level model

where only the equality relation of the first pair is represented and a high-level model where the lone intermediate

variable encodes the identity of the first input object (leaving all computation for the final step). These alternative

high-level models also solve the task perfectly.





**4.3. Discussion**











Figure 2: A causal model that computes

the hierarchical equality task.







The IIA results achieved by the best alignment for each high-level model can be seen in Table 1. The

best alignments found are with the ‘Both Equality Relations’ model that is widely assumed in the

cognitive science literature. For all causal models, DAS learns a more faithful alignment (higher

IIA) than a brute-force search through localist alignments. This result is most pronounced for ‘Both

Equality Relations’, where DAS learns perfect or near-perfect alignments under a number of settings,

whereas the best brute-force alignment achieves only 0.60 and the best localist alignment achieves

only 0.73. Finally, the distributed representation of left equality could not be decomposed into a

representation of the first argument identity. We see this in the very low performance of the ‘Identity

Subspace of Left Equality’ results. This indicates that models are truly learning to encode an abstract

equality relation, rather than merely storing the identities of the inputs.





10





FINDING DISTRIBUTED ALIGNMENTS





**Sentence Pairs** **Label**





_premise_ : A man is talking to someone in a taxi. _entails_

_hypothesis_ : A man is talking to someone in a car.





_premise_ : The people are **not** playing sitars. _neutral_

_hypothesis_ : The people are **not** playing instruments.





( _a_ ) Two MoNLI examples.







MONLIp **p** _,_ **h** q





1 _lexrel_ Ð GET-LEXRELp **p** _,_ **h** q

2 _neg_ Ð CONTAINS-NOTp **p** _,_ **h** q

3 **if** _neg_ :

4 **return** REVERSEp _lexrel_ q

5 **return** _lexrel_





( _b_ ) A simple program that

solves MoNLI.







Figure 4: Monotonicity NLI task examples and high-level model.





**4.4. Analyzing a Randomly Initialized Network**







To calibrate intuitions about our method, we evaluate the

ability of DAS to optimize for interchange intervention

accuracy on a frozen randomly initialized networks that

achieves chance accuracy (50%) on the hierarchical equality task. This investigates the degree to which random

causal structures can be used to systematically manipulate

the counterfactual behavior of the network. We evaluate

networks with different hidden representation sizes while

holding the four input vectors fixed at 4 dimensions, under the hypothesis that more hidden neurons create more

random structure that DAS can search through. These results are summarized in Table 4.4. Observe that, in small

networks, there is no ability to increase interchange intervention accuracy. However, as we increase the size of

the hidden representation to be orders of magnitude larger

than the input dimension of 16, the interchange intervention accuracy increases. This confirms our hypothesis and

serves as a check that demonstrates DAS cannot construct

entirely new behaviors from random structure.





**5. Monotonicity NLI Experiment**







Both Equality Relations





Hidden size Intervention size **Layer 1**





| **N** | “ 16 _k_ “ 8 0.50

| **N** | “ 64 _k_ “ 32 0.50

| **N** | “ 256 _k_ “ 128 0.51

| **N** | “ 1028 _k_ “ 512 0.55

| **N** | “ 4096 _k_ “ 2048 0.64





Figure 3: DAS on a random network

with a 16 dimension input.

An oversized hidden dimension allows DAS to manipulate the model behavior by

searching through a large

space of random mechanisms.







In our second experiment, we analyze a BERT model fine-tuned on the Monotonicity Natural

Language Inference (MoNLI) benchmark (Geiger et al., 2020). A MoNLI example consists of a

premise sentence and hypothesis sentence and the output label is _entails_ when the premise makes

the hypothesis true, and _neutral_ otherwise. Two examples are in Figure 4( _a_ ). Every example is such

that a single word _wp_ in the premise sentence was changed to a hypernym (more general term) or

hyponym (more specific term) _wh_ to create the hypothesis. About half of MoNLI examples contain a

negation that scopes over the word replacement site, and the remaining examples have no negation.

When no negation is present, the label for a premise–hypothesis pair is the lexical relation. When

negation is present, the label for a premise–hypothesis pair is the reverse of the lexical relation.





11





Negation and Lexical Entailment Identity of Lexeme Lexeme Subspace of

Lexical Entailment Lexical Entailment





Hidden size Intervention size **Layer 7** **Layer 9** **Layer 11** **Layer 7** **Layer 9** **Layer 11** **Layer 7** **Layer 9** **Layer 11** **Layer 9**





| **N** | “ 768 64 0.65 0.96 0.91 0.88 1.00 0.97 0.88 0.94 0.93 0.97

| **N** | “ 768 128 0.65 0.99 0.92 0.88 1.00 0.99 0.89 0.93 0.92 0.97

| **N** | “ 768 256 0.67 1.00 0.86 0.91 1.00 1.00 0.88 0.96 0.88 0.98





Brute-Force Search 0.60 0.56 0.52 0.64 0.64 0.57 0.50 0.51 0.54    Localist Alignment 0.51 0.51 0.51 0.47 0.47 0.47 0.50 0.50 0.50    



Table 2: Monotonicity NLI results. The table can be read as follows: **Layer 7**, **Layer 9**, and **Layer**

**11** indicate which layer of neurons is targeted, | **N** | is the number of neurons in a layer, _k_ is

the number of neurons aligned with each intermediate variable (red) where our subspace

model occupies _[k]_



2 [, and the values in each cell are interchange intervention accuracies for the]

learned alignment on training data. We report the best results from three runs with distinct

random seeds.





**5.1. Low-Level Neural Model**





We fine-tune an uncased BERT-base model (Devlin et al., 2019) finetuned on the MultiNLI dataset

(Williams et al., 2018). [4] Our BERT model has 12 layers and 12 heads with a hidden dimension of

768. We concatenate the tokenized sequences of the premise sentence and hypothesis sentence with a

rSEPs token. Because of the size of the rotation matrix, we can’t look for distributed representations

across all tokens; we look only at the representations of the rCLSs token because the final classification

is made from this token’s representation in the last layer.





**5.2. High-Level Models**





We use DAS to evaluate whether BERT fine-tuned on MoNLI will represent two boolean intermediate

variables. The first is an indicator variable for negation, which is true if and only if negation is present

in the premise and hypothesis. The second is a variable that is true if _wp_ entails _wh_ . This model is

perhaps best expressed as a simple program (Figure 4( _b_ )). Again, we also consider two alternative

high-level models to contextualize our results. One model represents only lexical entailment and not

negation. The other represents the identity of the premise word _wp_ .





**5.3. Results**





The IIA results achieved by the best alignment for each high-level model can be seen in Table 2. There

is a perfect alignment between fine-tuned BERT and a symbolic algorithm with variables representing

the presence of negation and the lexical entailment relation between _wp_ and _wh_ . In Table 2, this

is shown by the perfect IIA for layer 9 and intervention size 256, meaning 256 non-standard basis

dimensions of the rCLSs token representation in layer 9 of BERT encode the relation between _wp_

and _wh_ and 256 other non-standard basis dimensions encode negation. Across all alignments and

intervention types, DAS learns more faithful alignments (higher IIA) than a brute-force search

through alignments, and no localist alignment comes close to the learned distributed alignments in

terms of IIA.





4. The parameters are provided by the Hugging Face `transformers` library (Wolf et al., 2019), downloaded from



[https://huggingface.co/ishan/bert-base-uncased-mnli.](https://huggingface.co/ishan/bert-base-uncased-mnli)





12





FINDING DISTRIBUTED ALIGNMENTS





However, the distributed representation of the lexical entailment relation between _wp_ and _wh_ can

be nearly perfectly decomposed into two representations that encode the identity of the word _wp_ and

the identity of the word _wh_, respectively. This result is shown by the near perfect IIA in the final

column of Table 2. This tells us that what appeared to be a representation of the lexical entailment,

was in fact a “data structure” of two word identity representations.



**6. Conclusion**





We introduce distributed alignment search (DAS), a method to align interpretable causal variables

with distributed neural representations. We learn distributed alignments that are more interpretable

than localist alignments and do so with a gradient-descent based search method that improves upon

the state-of-the-art brute-force search. In our two experiments, we discovered perfect alignments of

distributed neural representations to binary high-level variables encoding simple equality and lexical

entailment relations. However, when we investigated the substructure of these representations, we

found that the lexical entailment representations could be decomposed into sub-representations of

word identity. This highlights the need to investigate the causal substructure of neural representations.

On the other hand, the presence of perfect representations of simple equality relations that cannot be

decomposed into representations of the entities in the relations is a foundational result that should

inform our understanding of how and when symbolic and connectionist architectures coexist.



**Acknowledgments**





This research is supported in part by grants from Open Philanthropy, Meta AI, Amazon, and the

Stanford Institute for Human-Centered Artificial Intelligence (HAI).



**References**





Eldar David Abraham, Karel D’Oosterlinck, Amir Feder, Yair Ori Gat, Atticus Geiger, Christopher

Potts, Roi Reichart, and Zhengxuan Wu. CEBaB: Estimating the causal effects of real-world

[concepts on NLP model behavior. arXiv:2205.14140, 2022. URL https://arxiv.org/abs/](https://arxiv.org/abs/2205.14140)

[2205.14140.](https://arxiv.org/abs/2205.14140)





Sander Beckers, Frederick Eberhardt, and Joseph Y. Halpern. Approximate causal abstractions. In

_Proceedings of The 35th Uncertainty in Artificial Intelligence Conference_, 2019.





Krzysztof Chalupka, Frederick Eberhardt, and Pietro Perona. Causal feature learning: an overview.

_Behaviormetrika_, 44:137–164, 2017.





Lawrence Chan, Adrià Garriga-Alonso, Nicholas Goldowsky-Dill, Ryan Greenblatt, Jenny Nitishinskaya, Ansh Radhakrishnan, Buck Shlegeris, and Nate Thomas. Causal scrubbing: a method for

rigorously testing interpretability hypotheses, 2022.





Róbert Csordás, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Are neural nets modular? inspecting

functional modularity through differentiable weight masks. In _9th International Conference on_

_Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021_ . OpenReview.net,

[2021. URL https://openreview.net/forum?id=7uVcpu-gMD.](https://openreview.net/forum?id=7uVcpu-gMD)





Nicola De Cao, Leon Schmid, Dieuwke Hupkes, and Ivan Titov. Sparse interventions in language

[models with differentiable masking. arXiv:2112.06837, 2021. URL https://arxiv.org/abs/](https://arxiv.org/abs/2112.06837)

[2112.06837.](https://arxiv.org/abs/2112.06837)





13





Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep

bidirectional transformers for language understanding. In _Proceedings of the 2019 Conference of_

_the North American Chapter of the Association for Computational Linguistics: Human Language_

_Technologies, Volume 1 (Long and Short Papers)_, pages 4171–4186, Minneapolis, Minnesota,

June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423. URL

[https://aclanthology.org/N19-1423.](https://aclanthology.org/N19-1423)





Yanai Elazar, Shauli Ravfogel, Alon Jacovi, and Yoav Goldberg. Amnesic probing: Behavioral explanation with amnesic counterfactuals. In _Proceedings of the 2020 EMNLP Workshop BlackboxNLP:_

_Analyzing and Interpreting Neural Networks for NLP_ . Association for Computational Linguistics,

November 2020. doi: 10.18653/v1/W18-5426.





Amir Feder, Nadav Oved, Uri Shalit, and Roi Reichart. CausaLM: Causal Model Explanation

Through Counterfactual Language Models. _Computational Linguistics_, pages 1–54, 05 2021.

[ISSN 0891-2017. doi: 10.1162/coli_a_00404. URL https://doi.org/10.1162/coli_a_00404.](https://doi.org/10.1162/coli_a_00404)





Matthew Finlayson, Aaron Mueller, Sebastian Gehrmann, Stuart Shieber, Tal Linzen, and Yonatan

Belinkov. Causal analysis of syntactic agreement mechanisms in neural language models. In _Asso-_

_ciation for Computational Linguistics and International Joint Conference on Natural Language_

_Processing (ACL-IJCNLP)_ [, 2021. URL https://aclanthology.org/2021.acl-long.144.](https://aclanthology.org/2021.acl-long.144)





Atticus Geiger, Ignacio Cases, Lauri Karttunen, and Christopher Potts. Posing fair generalization

tasks for natural language inference. In _Proceedings of the 2019 Conference on Empirical Methods_

_in Natural Language Processing and the 9th International Joint Conference on Natural Language_

_Processing (EMNLP-IJCNLP)_, pages 4475–4485, Stroudsburg, PA, November 2019. Association

[for Computational Linguistics. doi: 10.18653/v1/D19-1456. URL https://www.aclweb.org/](https://www.aclweb.org/anthology/D19-1456)

[anthology/D19-1456.](https://www.aclweb.org/anthology/D19-1456)





Atticus Geiger, Kyle Richardson, and Chris Potts. Neural natural language inference models

partially embed theories of lexical entailment and negation. In _Proceedings of the 2020 EMNLP_

_Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP_ . Association for

Computational Linguistics, November 2020. doi: 10.18653/v1/W18-5426.





Atticus Geiger, Hanson Lu, Thomas Icard, and Christopher Potts. Causal abstractions

of neural networks. In _Advances in Neural Information Processing Systems_, volume 34, pages 9574–9586, 2021. [URL https://papers.nips.cc/paper/2021/hash/](https://papers.nips.cc/paper/2021/hash/4f5c422f4d49a5a807eda27434231040-Abstract.html)

[4f5c422f4d49a5a807eda27434231040-Abstract.html.](https://papers.nips.cc/paper/2021/hash/4f5c422f4d49a5a807eda27434231040-Abstract.html)





Atticus Geiger, Alexandra Carstensen, Michael C Frank, and Christopher Potts. Relational reasoning

and generalization using nonsymbolic neural networks. _Psychological Review_, 2022a. doi:

[10.1037/rev0000371. URL https://doi.org/10.1037/rev0000371.](https://doi.org/10.1037/rev0000371)





Atticus Geiger, Zhengxuan Wu, Hanson Lu, Josh Rozner, Elisa Kreiss, Thomas Icard, Noah Goodman, and Christopher Potts. Inducing causal structure for interpretable neural networks. 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 7324–7338. PMLR, 17–23 Jul 2022b. URL

[https://proceedings.mlr.press/v162/geiger22a.html.](https://proceedings.mlr.press/v162/geiger22a.html)





14





FINDING DISTRIBUTED ALIGNMENTS





Atticus Geiger, Chris Potts, and Thomas Icard. Causal abstraction for faithful interpretation of AI

[models. arXiv:2106.02997, 2023. URL https://arxiv.org/abs/2106.02997.](https://arxiv.org/abs/2106.02997)





Jing Huang, Zhengxuan Wu, Kyle Mahowald, and Christopher Potts. Inducing character-level

structure in subword-based language models with Type-level Interchange Intervention Training.

[Ms., Stanford University and UT Austin, 2022. URL https://arxiv.org/abs/2212.09897.](https://arxiv.org/abs/2212.09897)





Yumi Iwasaki and Herbert A. Simon. Causality and model abstraction. _Artificial Intelligence_, 67(1):

143–194, 1994.





Alon Jacovi and Yoav Goldberg. Towards faithfully interpretable NLP systems: How should we

define and evaluate faithfulness? In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R.

Tetreault, editors, _Proceedings of the 58th Annual Meeting of the Association for Computational_

_Linguistics, ACL 2020, Online, July 5-10, 2020_, pages 4198–4205. Association for Computational

[Linguistics, 2020. doi: 10.18653/v1/2020.acl-main.386. URL https://doi.org/10.18653/v1/](https://doi.org/10.18653/v1/2020.acl-main.386)

[2020.acl-main.386.](https://doi.org/10.18653/v1/2020.acl-main.386)





Belinda Z. Li, Maxwell I. Nye, and Jacob Andreas. Implicit representations of meaning in

neural language models. In Chengqing Zong, Fei Xia, Wenjie Li, and Roberto Navigli, editors, _Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics_

_and the 11th International Joint Conference on Natural Language Processing, ACL/IJCNLP_

_2021, (Volume 1: Long Papers), Virtual Event, August 1-6, 2021_, pages 1813–1827. Association for Computational Linguistics, 2021. doi: 10.18653/v1/2021.acl-long.143. URL

[https://doi.org/10.18653/v1/2021.acl-long.143.](https://doi.org/10.18653/v1/2021.acl-long.143)





Zachary C. Lipton. The mythos of model interpretability. _Commun. ACM_, 61(10):36–43, 2018. doi:

[10.1145/3233231. URL https://doi.org/10.1145/3233231.](https://doi.org/10.1145/3233231)





Qing Lyu, Marianna Apidianaki, and Chris Callison-Burch. Towards faithful model explanation

in NLP: A survey. _CoRR_, abs/2209.11326, 2022. doi: 10.48550/arXiv.2209.11326. URL

[https://doi.org/10.48550/arXiv.2209.11326.](https://doi.org/10.48550/arXiv.2209.11326)





Riccardo Massidda, Atticus Geiger, Thomas Icard, and Davide Bacciu. Causal abstraction with

soft interventions. In Mihaela van der Schaar, Cheng Zhang, and Dominik Janzing, editors,

_Conference on Causal Learning and Reasoning, CLeaR 2023, 11-14 April 2023, Amazon Devel-_

_opment Center, Tübingen, Germany, April 11-14, 2023_, volume 213 of _Proceedings of Machine_

_Learning Research_ [, pages 68–87. PMLR, 2023. URL https://proceedings.mlr.press/v213/](https://proceedings.mlr.press/v213/massidda23a.html)

[massidda23a.html.](https://proceedings.mlr.press/v213/massidda23a.html)





J. L. McClelland, D. E. Rumelhart, and PDP Research Group, editors. _Parallel Distributed Processing._

_Volume 2: Psychological and Biological Models_ . MIT Press, Cambridge, MA, 1986.





Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing

factual associations in GPT. In _Advances in Neural Information Processing Systems_

_(NeurIPS)_ [, 2022. URL https://proceedings.neurips.cc/paper_files/paper/2022/file/](https://proceedings.neurips.cc/paper_files/paper/2022/file/6f1d43d5a82a37e89b0665b33bf3a182-Paper-Conference.pdf)

[6f1d43d5a82a37e89b0665b33bf3a182-Paper-Conference.pdf.](https://proceedings.neurips.cc/paper_files/paper/2022/file/6f1d43d5a82a37e89b0665b33bf3a182-Paper-Conference.pdf)





Chris Olah, Nick Cammarata, Ludwig Schubert, Gabriel Goh, Michael Petrov, and Shan Carter.

Zoom in: An introduction to circuits. _Distill_, 2020. doi: 10.23915/distill.00024.001.

https://distill.pub/2020/circuits/zoom-in.





15





Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan,

Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli,

Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane

Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish,

and Chris Olah. In-context learning and induction heads. _Transformer Circuits Thread_, 2022.

https://transformer-circuits.pub/2022/in-context-learning-and-induction-heads/index.html.





Judea Pearl. Direct and indirect effects. In _Proceedings of the Seventeenth Conference on Uncer-_

_tainty in Artificial Intelligence_, UAI’01, page 411–420, San Francisco, CA, USA, 2001. Morgan

Kaufmann Publishers Inc. ISBN 1558608001.





David Premack. The codes of man and beasts. _Behavioral and Brain Sciences_, 6(1):125–136, 1983.

[doi: 10.1017/S0140525X00015077. URL https://doi.org/10.1017/S0140525X00015077.](https://doi.org/10.1017/S0140525X00015077)





Shauli Ravfogel, Yanai Elazar, Hila Gonen, Michael Twiton, and Yoav Goldberg. Null it out:

Guarding protected attributes by iterative nullspace projection. In Dan Jurafsky, Joyce Chai,

Natalie Schluter, and Joel R. Tetreault, editors, _Proceedings of the 58th Annual Meeting of the_

_Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020_, pages 7237–7256.

Association for Computational Linguistics, 2020. doi: 10.18653/v1/2020.acl-main.647. URL

[https://doi.org/10.18653/v1/2020.acl-main.647.](https://doi.org/10.18653/v1/2020.acl-main.647)





Shauli Ravfogel, Michael Twiton, Yoav Goldberg, and Ryan D Cotterell. Linear adversarial concept

erasure. In _International Conference on Machine Learning (ICML)_ [, 2022. URL https://](https://proceedings.mlr.press/v162/ravfogel22a.html)

[proceedings.mlr.press/v162/ravfogel22a.html.](https://proceedings.mlr.press/v162/ravfogel22a.html)





Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. "why should i trust you?": Explaining the

predictions of any classifier. In _Proceedings of the 22nd ACM SIGKDD International Conference_

_on Knowledge Discovery and Data Mining_, KDD ’16, page 1135–1144, New York, NY, USA, 2016.

Association for Computing Machinery. ISBN 9781450342322. doi: 10.1145/2939672.2939778.

[URL https://doi.org/10.1145/2939672.2939778.](https://doi.org/10.1145/2939672.2939778)





Eigil F. Rischel and Sebastian Weichwald. Compositional abstraction error and a category of causal

models. In _Proceedings of the 37th Conference on Uncertainty in Artificial Intelligence (UAI)_,

2021.





Paul K. Rubenstein, Sebastian Weichwald, Stephan Bongers, Joris M. Mooij, Dominik Janzing,

Moritz Grosse-Wentrup, and Bernhard Schölkopf. Causal consistency of structural equation

models. In _Proceedings of the 33rd Conference on Uncertainty in Artificial Intelligence (UAI)_,

2017.





D. E. Rumelhart, J. L. McClelland, and PDP Research Group, editors. _Parallel Distributed Processing._

_Volume 1: Foundations_ . MIT Press, Cambridge, MA, 1986.





P. Smolensky. Neural and conceptual interpretation of PDP models. In _Parallel Distributed Pro-_

_cessing: Explorations in the Microstructure, Vol. 2: Psychological and Biological Models_, page

390–431. MIT Press, Cambridge, MA, USA, 1986. ISBN 0262631105.





Peter Spirtes, Clark Glymour, and Richard Scheines. _Causation, Prediction, and Search_ . MIT Press,

2000.





16





FINDING DISTRIBUTED ALIGNMENTS





Roger K R Thompson, David L Oden, and Sarah T Boysen. Language-naive chimpanzees (pan

troglodytes) judge relations between relations in a conceptual matching-to-sample task. _Journal of_

_Experimental Psychology: Animal Behavior Processes_, 23(1):31—-43, 1997.





Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,

Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In I. Guyon, U. V. Luxburg,

S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, _Advances in Neural_

_Information Processing Systems 30_, pages 5998–6008. Curran Associates, Inc., 2017. URL

[http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf.](http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf)





Jesse Vig, Sebastian Gehrmann, Yonatan Belinkov, Sharon Qian, Daniel Nevo, Yaron Singer, and

Stuart Shieber. Causal mediation analysis for interpreting neural nlp: The case of gender bias,

2020.





Kevin Wang, Alexandre Variengien, Arthur Conmy, Buck Shlegeris, and Jacob Steinhardt. Interpretability in the wild: a circuit for indirect object identification in GPT-2 small. _arXiv preprint_

_arXiv:2211.00593_ [, 2022. URL https://arxiv.org/abs/2211.00593.](https://arxiv.org/abs/2211.00593)





Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for

sentence understanding through inference. In _Proceedings of the 2018 Conference of the North_

_American Chapter of the Association for Computational Linguistics: Human Language Technolo-_

_gies, Volume 1 (Long Papers)_, pages 1112–1122. Association for Computational Linguistics, 2018.

[URL http://aclweb.org/anthology/N18-1101.](http://aclweb.org/anthology/N18-1101)





Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi,

Pierric Cistac, Tim Rault, R’emi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface’s

transformers: State-of-the-art natural language processing. _ArXiv_, abs/1910.03771, 2019.





Zhengxuan Wu, Karel D’Oosterlinck, Atticus Geiger, Amir Zur, and Christopher Potts. Causal

[Proxy Models for concept-based model explanations. arXiv:2209.14279, 2022. URL https:](https://arxiv.org/abs/2209.14279)

[//arxiv.org/abs/2209.14279.](https://arxiv.org/abs/2209.14279)





17





**Supplementary Materials**



**Appendix A. Experimental Setup Details**





**A.1. Training Data for distributed alignment search (DAS)**





For each task, we create training datasets for learning the rotation matrix of each high-level model.

As defined in Definition 2, each input–output pair for training the rotation matrix consists of a base

input that has two pairs of input values. Additionally, we have a set of source inputs mapping to

interventions on different intermediate variables, and the corresponding counterfactual outputs (i.e.,

the updated outputs under interventions). Note that only for cases where there are multiple high-level

intermediate variables involved, we sample more than one source input. For such cases, we randomly

choose to interchange two variables together from two source inputs or swap a single variable from a

single source input.





**Hierarchical Equality Experiments** For our high-level models abstracting both equality relations

and left equality relation, we sample a set of source inputs and interchange the equality relations of

the corresponding shape pairs from the source inputs with the equality relations from the base input.

For our high-level model abstracting the identity of the first shape, we sample a source input and

interchange the first change from the source input with the base input.





**Monotonicity NLI Experiments** For our high-level models abstracting negation or lexical entailment, we sample a set of source inputs and interchange the boolean value for negative or the value for

lexical entailment from the source inputs with the base input. For our high-level model abstracting

only the identity of replacing lexeme from the _hypothesis_ sentence, we sample another _hypothesis_

sentence from the one seen in training set and interchange its lexeme with the base input. To avoid

cases where entailment labels are invalid (e.g., the entailment relation between “car” and “tree” is

ambiguous), we specifically sample a valid English word that is either a hypernym or a hyponym

of the lexeme item in the _premise_ sentence, and from a new lexeme pair. Then, we construct a new

pair of _premise_ and _hypothesis_ sentences by sampling a sentence template (i.e., a sentence with

replaceable lexeme position such as “a man is talking to someone in a [lexeme]”) from the training

dataset and replacing the lexeme items with new ones.





**A.2. Reproducibility**





**Hierarchical Equality Experiment** We randomly generate 1.92M input–output pairs for training

the model. We train our model for 10 epochs before reaching 100% training accuracy for the task.

We also evaluate model performance on a hold-out testing set with unseen input-output pairs, and our

model achieves 100% testing accuracy. For each high-level model, we then generate a training dataset

for learning the rotation matrix. For each high-level model, we construct 640K such input–output

pairs as our training data and 19.2K pairs as our testing data.

For both training phases, we use a batch size of 6.4K with a maximum training epoch of 10.

We set the learning rate to 1e [´][3] with an early stop patient step set to 10K. Training with a single

NVIDIA 2080 Ti RTX 11GB GPU takes less than ten minutes to converge. All datasets were

balanced across the two labels during standard and interchange intervention training objectives. We

run each experiment three times with distinct random seeds.





**Monotonicity NLI Experiment** We randomly sample 10K examples from the original MoNLI

dataset and use it to train our low-level models to solve MoNLI. We finetune our model for 5 epochs

before reaching 100% training accuracy for the task. We also evaluate model performance on a





18





FINDING DISTRIBUTED ALIGNMENTS





hold-out testing set, and our model achieves 100% testing accuracy. For training and evaluating the

rotation matrix of each high-level model, we create 24K examples as our training dataset for the first

high-level model, and 10K for the rest two high-level models. For evaluation, we create 1.92K for

the first high-level model, and 1K for the rest two high-level models.

We finetune our model for 5 epochs with a learning rate of 2 _e_ [´][5] before reaching 100% task

accuracy with a batch size of 32. For the learning rotation matrix, we use a batch size of 64 with a

learning rate of 2 _e_ [´][3] for a fixed epoch number of 5. Training with a single NVIDIA 2080 Ti RTX

11GB GPU takes less than ten minutes to converge for both training phases. We run each experiment

three times with distinct random seeds.





**A.3. Brute-Force Search Baseline**





Without additional training, our brute-force search baseline finds the best IIA by searching over

possible alignments pΠ _,_ _τ_ q as in Definition 5. For simple feed-forward networks, we map a high-level

variable to a set of low-level variables within a sliding window with a size equal to the intervention

size. We then incrementally search for the sliding window achieving the best IIA score starting from

the first index of the intervened representation in the network. For Transformer-based networks,

we avoid searching over all possible windows to make computation tractable, by only looking at

windows with a starting index from t0 _,_ 64 _,_ 128 _,_ 256 _,_ 512u of the rCLSs token representation. Instead

of targeting a specific set of layers in neural networks, we perform searches over all layers. Note that

for the worst-case scenario, the number of hypotheses for the brute-force search approach becomes

intractable and can be estimated as _Cm_ _[n]_ [where] _[ n]_ [ is the total dimension size of the neural representation,]

and _m_ is the variable dimension size.





19





**A.4. Localist Alignment Baseline**





Without additional training, our localist alignment baseline finds a local optimal localist alignment

matrix based on the learned rotation matrix. We pick the rotation matrix with the best IIA result from

each category for evaluation. To find a localist alignment matrix, we follow Algorithm 1 to get our

localist alignment matrix _L_ from any orthogonal matrix _R_ . We then use _L_ as our rotation matrix

and evaluate IIA following our evaluation paradigm.





**Algorithm 1 Finding Localist Alignment Matrix**





FINDLOCALISTALIGNMENTp _R_ q



1 **//** _R_ is an orthogonal matrix.

2 _R_ a “ _R.aboslute_ _ _value_ pq

3 _L_ “ torch.zeros_likep _R_ q

4 _P_ “ rs

5 **for** _i_ “ 0; _i_ ă _R_ .shape[0]; _i_ ``

6 _P_ `“ rp _R_ a “ torch.maxp _R_ aqq.nonzero()s

7 _R_ ar _P_ r´1s.row _,_ :s “ 0 _._

8 _R_ ar: _,_ _P_ r´1s.cols “ 0 _._

9 **for** _p_ P _P_

10 _L_ r _p_ .row _, p._ cols “ 1 _._

11 _P_ “ _P_ ˚ get_signp _R_ q

12 **return** _P_





20





FINDING DISTRIBUTED ALIGNMENTS





**A.5. Subspace DAS**





After learning a rotation matrix, we can fix it and learn another rotation matrix on top of it to do

subspace high-level variable alignment. For instance, in the case of our MoNLI experiment, we fix

the rotation matrix aligning the Lexical Entailment representation and further test whether we can

learn another rotation matrix to align word identity. To achieve this, we initialize the first rotation

matrix which aligns a larger subspace and freezes its weights along with the rest of the model. Then,

we train another rotation matrix by taking the output representations from the first one with the

same training objective as the first one as defined in Definition 4. The training data for the second

rotation matrix is not the same as the first one, where we use the training data for the high-level

model hypothesized to align with the subspace (e.g., the training data for the identity of first argument

for the hierarchical equality task, and the training data for the identity of lexeme for the MoNLI

task). Note that for both of our experiments, the subspace dimension is half of its parent subspace for

simplicity.



**Appendix B. Runtime Comparison: Brute-force Search Baseline vs. DAS**





Table 3 shows the runtime comparison between our method and brute-force search under the same

settings for each task. Only our approach requires training. We underestimate the runtime for

the brute-force search approach by only considering a limited set of possible alignments without

exhaustively searching over the entire combination, which leads to intractable computations (See the

BFSmax column of Table 3). The runtime of our approach can be further optimized if we deploy early

stopping or optimized training data size, and it is invariant with the number of testing hypotheses.





Table 3: Estimated runtime comparison between our method and brute force search (BFS) baseline

(the number of testing hypotheses) for finding an alignment in a single targeted layer

measured under the same settings. The runtime of DAS is invariant with the number of

testing hypotheses.





**Runtime (sec)**

**Task** **BFS** **BFS** max **DAS**



Hierarchical Equality 31 (32) 6 _e_ [8] ( _C_ 16 [32][)] 502





Monotonicity NLI 198 (5) 2 _e_ [58] ( _C_ 32 [768][)] 1105





**Appendix C. Remarks on Learned Rotation Matrix**



Figure 5 shows the rotation in degree(s) of eigenvectors [5] of our learned rotation matrix for each task.

We pick the best-performing oracle low-level model for each task for analyses. Our results suggest

that learned rotations are not trivial, as the majority of basis vectors are rotated. These results suggest

that the representations of high-level variables are highly distributed where direct probes over learned

activation may fail to reveal the actual causal role of the representation effectively.



**Appendix D. Common Questions**





In this section, we answer common questions that may be raised while reading this report.





_Is the learned orthogonal matrix orthonormal?_





5. The eigenvectors of a rotation matrix are the vectors that remain unchanged after the rotation.





21





Figure 5: Rotation measured in degree(s) of eigenvectors of the learned rotation matrix for each task.





Yes. We use the trainable orthogonal matrix implementation from PyTorch’s torch.nn.utils.

parametrizations. It guarantees the resulting matrix is orthonormal when the rotation matrix is a

full square matrix. Keeping the matrix orthonormal is crucial since it ensures we focus on rotation

[rather than scaling. Details can be found at https://pytorch.org/docs/stable/generated/](https://pytorch.org/docs/stable/generated/torch.nn.utils.parametrizations.orthogonal.html)

[torch.nn.utils.parametrizations.orthogonal.html.](https://pytorch.org/docs/stable/generated/torch.nn.utils.parametrizations.orthogonal.html)





_How stable is the optimization process of the orthogonal matrix?_





We rely on the default initialization of the orthogonal matrix in pytorch. The initialization

step is important for finding the local optimal of the rotation matrix. In our experiment, we use

random seeds and pick the best results out of our distinct runs to address this issue. However, we

may consider different initialization schemes in the future.





_Is an orthogonal matrix required to find distributed alignments?_





In principle, the transformation is not required to be an orthogonal matrix. In fact, an orthogonal

matrix assumes a linear transformation before aligning with a high-level variable, which may not

be optimal if the aligning variable is represented in a non-linear sub-manifold of the representation

space. In such cases, an orthogonal transformation results in imperfect interchange intervention

accuracy, and an invertible and differentiable non-linear transformation may be more suitable (e.g.,

normalizing flow or invertible neural network). In practice, this transformation is computationally

difficult to find, and the linear connections within neural networks also make them unlikely to be

required to find alignments. We leave these investigations to future works.





_What are the prerequisites to deploy this analysis method in practice?_





We assume a partial or complete causal graph of the data generation process. Specifically, we

assume to have interchangeable high-level variables defined for the causal graph. Additionally, we





22





FINDING DISTRIBUTED ALIGNMENTS





assume we can sample counterfactual data (i.e., base and source inputs where they differ in values of

high-level variables) based on the causal graph.





_How to interpret the result if the interchange intervention accuracy is not 100%?_





When IIA is _α_ ă100%, we rely on the graded notion of _α-on-average_ approximate causal

abstraction Geiger et al. (2023), which directly coincides with IIA. More importantly, the relative IIA

rankings between the high-level models also show which high-level model is a better approximation

of the low-level model.





_Does DAS scale with large foundation models?_





Currently, the number of learnable parameters of the rotation matrix groups in polynomial time

with the size of hidden representations. For instance, if our intervention site size is 512 in the

lower-level model, the number of parameters of the rotation matrix is 512 ˆ 512, which is about

0.26M. If we want to rotate concatenated token sequence embeddings of a BERT-BASE model in any

layer, the number of parameters of the full rotation matrix is about 15.4B which becomes intractable

for standard training infrastructure. To make computation tractable, DAS should be further reducible

by representing only the aligned subspace, not the full rotation matrix. For instance, to find a 2-dim

distributed representation within a 512-dimensional representation space, we approximately only

need to learn 512 ˆ 2 parameters. In addition, we may use a low-rank approximation of the rotation

matrix.





_What are some practical usage of DAS?_





Practically, DAS transforms representations into an operatable state where interchange intervention results in interpretable model behaviors. DAS, itself, is a powerful tool for conducting causal

abstraction analysis of a neural network.



**Appendix E. Task Performance & Interchange Intervention Accuracy Over Training**

**Epochs**





We additionally measure task performance (Task Acc.) as well IIA (Int. Acc.) of our alignments over

training epochs for both seen training examples as well as unseen testing examples. Our results are

shown from Figure 6 to Figure 11.





23





( _a_ ) | **N** | “ 16





( _b_ ) | **N** | “ 32





Figure 6: Accuracy over training epochs of the high-level model abstracting both equality relations

for hierarchical equality experiment.





24





FINDING DISTRIBUTED ALIGNMENTS





( _a_ ) | **N** | “ 16





( _b_ ) | **N** | “ 32





Figure 7: Accuracy over training epochs of the high-level model abstracting left equality relation for

hierarchical equality experiment.





25





( _a_ ) | **N** | “ 16





( _b_ ) | **N** | “ 32





Figure 8: Accuracy over training epochs of the high-level model abstracting identity of first argument

for hierarchical equality experiment.





26





FINDING DISTRIBUTED ALIGNMENTS





Figure 9: Accuracy over training epochs of the high-level model abstracting both negative and lexical

entailment with | **N** | “ 768 for monotonicity NLI experiment.





Figure 10: Accuracy over training epochs of the high-level model abstracting lexical entailment with

| **N** | “ 768 for monotonicity NLI experiment.





27





Figure 11: Accuracy over training epochs of the high-level model abstracting the identity of lexeme

with | **N** | “ 768 for monotonicity NLI experiment.





28