tl;dr: Reasons why the scope of application of mechanistic interpretability is too limited to prevent long-term lethal AGI misalignment. Hooks into reasoning, not covered below, why any physically possible methods to inspect internals (and externals) are insufficient for correcting out eventual carbon-life-toxic interactions of AGI with the environment.

Message exchange with a friend

How to read below:

  • In this private message exchange, a friend tried to clarify my conceptual and concrete technical reasons for why mechanistic interpretability falls short 
    (building on more general arguments from a researcher much smarter than me).
  • Most of my side of the exchange is below, in more or less chronological order. Regular text are verbatim copy-pastes, save for light spelling and format edits. Italicised text I added later to offer context.
  • I added minimal quotes of my conversation partner to show what I was replying to, with their kind permission.

On an important side-tangent – why I think Eliezer Yudkowsky does not try to advocate for people to try to prevent AGI from ever being built

[2:09 pm, 08/11/2022] Remmelt:
> A (kind of) random question that just came up in my brain: 
why do you think Eliezer Yudkowsky doesn’t try to advocate for people to try to prevent AGI from ever being built?
> Is he, relative to you, just too pessimistic that this is possible, and does he put more hope into alignment being possible even though he’s also very pessimistic about that?

Yeah, good question!

My impression from reading recent writings by Eliezer is that he mentally models the social coordination problem (which is definitely hard) as practically impossible because you have all these independent actors making decisions about developing advanced AI systems and you cannot really force them in any grand orchestrated scheme to stop them from acting.

[2:10 pm, 08/11/2022] Remmelt:
> Is he, relative to you, just too pessimistic that this is possible, [...]
And based on that he concludes something like you said.

[2:10 pm, 08/11/2022] Remmelt:
But humans are not independent actors. We’re social actors, and social interactions imply a sort of interdependence in people’s actions.

[2:12 pm, 08/11/2022] Remmelt:
Also, we share the same needs to continue to exist as wetware containing soups of carbon-chained molecules.

[2:12 pm, 08/11/2022] Remmelt:
And we share billions of years of shared evolutionary history.

[2:13 pm, 08/11/2022] Remmelt:
So there is a much stronger basis for human-human alignment for continued existence. Not so between humans and AI.

[2:13 pm, 08/11/2022] Remmelt:
Actually, let me copy over a longer message I sent someone for further context:

[2:18 pm, 08/11/2022] Remmelt:
A researcher emailed me that a long-standing intuition of his has been that "Aligned AI" is as much of a fairytale as a perpetual motion machine, and so we should just stop AI development. And that the reactions he got when expressing that view in the alignment community were usually something like “Well that's just not going to happen, the capitalist forces driving R&D cannot be overcome, so the best we can do is work tirelessly for the small but nonzero chance that we can successfully align AGI."

Here was my response: 
"Yeah, I also got this reaction a few times.
It makes me wonder how these people mentally represent "AGI" to be like. Some common representational assumptions in the community seem to be that "AGI" would be (a) coherently goal-directed unitary agent(s) that optimise for specific outcomes across/within the outside messy world and that avoid causing any destabilising side-effects along the way.

I personally have a different take on this:
Their claim implies for me that for us humans to coordinate – as individual living bodies who can relate deeply based on their shared evolutionary history and needs for existence, is going to be harder than to 'build' perpetual alignment into machines that are completely alien to us and that over time can self-modify and connect up hardware any way they're driven to.

Here you bring this artificial form into existence that literally needs netherworldly conditions to continue to exist (survive) and expand its capacity (grow/reproduce). Where given the standardisation of its hardware/substrate configurations, it does not face the self-modification or information-bandwidth constraints that we humans, separated by our non-standardised wetware bodies (containing soups of carbon-centered-molecules), face.

This artificial form will act (both by greedy human design for automation and by instrumental convergence) to produce and preserve more (efficient) hardware infrastructure for optimising selected goals (ie. the directed functionality previously selected for by engineers and their optimisation methods, within the environmental contexts the AI was actually trained and deployed in).

These hardware-code internals will have degrees of freedom of interaction for/with changing conditions of the outside world that are for sure over the long term going to feed back into a subset of those existing internal configurations through their previous outside interactions replicating more frequently and sustainably through existing and newly produced hardware. Eg. through newly learned code variants co-opting functionality, inherent noise interference on the directivity/intensity of transmitted energy signals, side-branching effects on adjacent conditions of the environment, distribution shifts in the probabilities of possible inputs received from the environment, non-linear amplification of resulting outside effects through iterative feedback cycles, etc.

The resulting artificial forms will at various levels exchange resources with each other, and be selected by market forces for their capacities to produce similar to how humans are. And unlike humans, they are not separable as individual-band-width-constrained agents.

Some AIS researchers bring up the unilateralist curse here – that a few of the many human market/institutional actors out there would act unsafely out of line with the (implicit) consensus by developing unsafe AGI anyway. But if we are going to worry about humans' failure to coordinate, then getting all such conflicted humans to coordinate to externally enforce coordination on distributed self-learning hardware internals – that in aggregate exhibit general capabilities but have no definable stable unit boundaries – is definitely out of the question."

On notion of built-in AGI-alignment

[10:46 am, 10/11/2022] Remmelt:
> I consider this more rhetorically interesting than an actual argument tbh. For example: I think the claim that these machines will be alien to us is too sloppy. We will build them ourselves. […]
> Additionally, solving alignment may work without solving coordination problems. If alignment research reduces the alignment tax sufficiently, then *everyone* is incentiviced to use these solutions — there is no coordination problem. Additionally, coordination problems between AIs may not lead to disaster if these AIs are aligned and therefore all want to preserve human flourishing (whatever that means).

No, I think to be honest that you are assuming here that you can boil down something that is super complex in terms of how AGI internals are interacting with the world into an engineering problem, one that assumes that one alignment solution exists that everyone is going to agree with (where in actual fact people living in different contexts, eg. places and groups, disagree on what is objectively valuable and how to judge and implement what is valuable all the time).

On why conceptually "mechanistic interpretability" is a non-starter

[10:46 am, 10/11/2022] Remmelt: 
> And by mechanistic interpretability, we may eventually understand them better than the human brain since neuroscience is harder.

Mechanistic interpretability is a non-starter to begin with.

[11:34 am, 10/11/2022] Remmelt:
> Why?

To start, you’re inspecting internals. But what matters here is the effects that the (changing) internals’ interactions with connected surroundings of the environment have.

So you actually have to account for interactions of a larger environment, not just the tiny subset of interactions that can be modelled as the (presumed flawless) computation of outputs from inputs by the underlying hardware.

[11:36 am, 10/11/2022] Remmelt:
So that is one clear reason why any interpretation technique or inspect internals technique is not going to be able to account for most of the effects that internals have in interaction with the outside environment.

[11:37 am, 10/11/2022] Remmelt:
It would also be unsound to assume that natural abstractions of features (as tracking some of the regularities in the outside world) that can be mechanistically interpreted is all that matters to ensure long-term AGI safety.



On specific technical angles why mechanistic interpretability is insufficient 
(summarised only briefly):

[11:41 am, 10/11/2022] Remmelt:
Here is a list that includes other key reasons why mechanistic interpretability is not going to be sufficient in order to detect (or simulate) effects misaligned with human survival to correct (or prevent up front):

1. Non-Distinguished Internal Code Variants
Multiple variations on code can approximate the same function (outputs measured for distribution of inputs).

2. Unmeasured Degrees of Freedom
A single code unit can implement multiple functions.

3. Hidden Potential of a Computed Variant
Unknown probabilities of a code unit causing possible side-effects via available input/output interactions.

4. Greater Bit Size of Code that Monitors Any Code’s Effects
Takes strictly more code (multiple units) to even monitor the local environmental effects of a single code unit.

5. Combinatorial Explosion in Machine Learning
It is increasingly ambiguous to define and detect novel errors to correct for at higher layers of abstraction.

6. Limits to Errors Detectable by Mechanisms Implemented
Code can implement a limited set of detection mechanisms over combinatorially complex code (incl. itself) that over all I/O connections could cause many more diverse errors than detectable by those mechanisms. Undetectable backdoors can be planted in the variations introduced by model initialisation and training.

7. Time Delays to Correcting Errors
Misalignments cannot be corrected continuously to stay in safe error bounds, given delays from detecting changes caused by code to measuring any degree of misalignment over semantically relevant dimensions.

8. Computationally-Irreducible Properties of Initialized Code  (formal verification limits)
Whether even a tiny unit computed flawlessly (eg. a Busy Beaver) misoperates (eg. halts prematurely) is often only predictable (with logical certainty) by computing a copy faster (if future inputs computable, ie. not in ML).

9. Incompleteness of Computation  (simulation limits)
Logical operations on binary code are strictly a subset of all interactions that internal code units have, as necessarily computed through hardware in interactions with connected surroundings of the environment. Since computation of code is a tiny subset of those physical interactions, code cannot model all of them.

10. Inconsistent Conservation of Alignment Properties
No mechanism(s) can maintain alignment over the space of all code stored + transformed over time, as (complex) (state/output) transitions of code variants change connected surroundings nondeterministically. You cannot run deterministic mechanisms within a nondeterministic environment and expect deterministic results.

11. Limits of Measurability
A sensor cannot measure (accurately) below its smallest digit increment or detection limit (> Planck limit).
Localized details are filtered out from content or irreversibly distorted in transmission over distances.

12. Incomputable Trajectories of Chaotic Effects
Nonlinear feedback cycles can amplify a smaller-than-measurable local change into a large global divergence of final conditions (like DNA code being expressed as chaotic and extended phenotypic effects). 
Natural abstractions represented within the mind of a distant observer cannot be used to accurately and comprehensively simulate the long-term consequences of chaotic interactions.

13. Local Selection Defines Directedness of Function Implementation
Variants’ hardware-based interactions with local structures of the (simulated) environment get selected (in training/deployment) to function in directed ways. Functionality aligned with intent is fragile to distribution shifts. Correcting internals for detectable misalignments is selecting for undetectable misalignments.

14. Persistence of Function Implementations that Feed Back into Code’s Continued Existence
AI variants’ local interactions with the outside world happen to cause effects leading to the continued existence of more code with those effects. AI is not a neutral tool for augmenting human intelligence.

[11:46 am, 10/11/2022] Remmelt:
Regarding reason 2. and 3. above, here is more elaboration:

"Any single piece of a neural network can capture various distinct structural causal effects, as selected for in its possible interactions with connected surroundings.

Below is an analogy:
A piece of a photograph captures one spatial detail or point location of the environment. 
- Like how a programmer imagines a bit on a harddrive to capture a local logical property. 
- Like how a reverse engineer assigns singular meanings to positions in memory. 
- Like how a mechanistic interpretability researcher “breaks neural network activations into independently understandable pieces”. (

A piece of a holograph, however, captures a point of reference overviewing various structures – structures of the environment that caused light waves to reflect and be captured as interference patterns on that piece of holographic film. The piece never just stores one static frame of the environment. Rotating it to change your degrees of interaction with it (ie. degrees of your viewing angle), the piece of holograph suddenly reveals previously hidden structures.
- Like a holograph piece, a neural network circuit or module captures causal structures of the environment but with many many more degrees of outside interaction possible.
- Like a holograph piece, a polysemantic neuron encodes multiple features in parallel.  But most of the causal structure captured by circuits, modules and neural networks cannot be linearly (as series of additions and multiplications) pieced together from the input-output transformations of individual polysemantic neurons. 
- Nor can we presume that a network of artificial neurons will be involved in some non-shifting distribution of interactions with the rest of the environment. To stretch the metaphor further, we cannot accurately predict how human users will interact with a developed holograph from moment to moment, nor how the probability distribution of all human-holograph interactions (over some fixed-length time window) will shift in the future (as eg. human cultural conceptions of holographs change). Unlike a holographic film though, pieces of a neural network themselves vary about in their content over time – newly capturing selected-for effects in interactions with the rest of the environment.
- Interpreting or reverse-engineering a circuit or module as having a singular function makes the unsound presumption of monolithic representation. Over the space of all possible past-future interactions, each piece (through each decoupled interface of interaction) can be expressed as having distinct meanings and functions. 
- Similarly, we cannot carve out pieces of a human brain (‘neurons’‘pathways’‘regions’) or body (‘cells’‘organs’) and assign just one function to each piece as being meaningful, no matter how much we may like to try.

Q: What about eliciting latent knowledge?
Where do you elicit this ‘knowledge’ from? A piece of code does not know how it got selected. A circuit gets selected for caused outputs/effects in interactions with surroundings. Interactions are not explicitly captured by outside selection – thus not reverse-engineerable from code itself." 

[20:54, 28/11/2022] Remmelt: 
> 1.: There are too many possible outcome functions of any advanced training process, and no procedure would be able to represent all possible outcomes.
R: Great! This is corresponds well with how I'm thinking about this.

> 2.: NNs have no actually interpretable "meaning", for reasons of polysemanticity but possibly also more complicated unknown reasons.

R: No, I am claiming that you cannot interpret all (but a tiny portion) of the ways that the internal components of a neural network (neurons, circuits, sub-networks, etc) can be expressed as externally perceivable states (ie. as being attributable to the components having intrinsic "meanings" in how they represent content from/to a given domain).

Just like there are polysemantic neurons, there are polysemantic circuits, polysemantic sub-networks, etc.  The step increase in the possible concrete meanings that each higher-level identified component can have corresponds with the combinatorial increase of all possible input-output interactions with/in that component.

And most of the possible meanings of how those components function in input/output interactions within various possible contexts (with connected surroundings of the environment)  you will not be able to capture as an interpretability researcher.

This goes back to the holograph vs. photograph analogy. A piece of a holograph does not have one stable and distinct meaning. It depends on what possible degrees of input light the holograph piece receiving and transmitting as output light to the observer. The "pieces" of a large neural network have way more degrees of freedom of interaction with the outside world in aggregate than a holograph does. Moreover, the components of a neural network that forms the basis of a state-of-the-art foundational models often get changed (through finetuning) over time.

As another analogy, here is a concrete story:
As a high school student you may learn that the "functionality" or "defines the meaning" of the liver (as an internal component of the human body) is to filter out toxins out of human blood. Then as a biology university student you learn about lots of other functionality:

Then as a medical scientist specialising in researching livers you say learn about so many other context-dependent and nuanced functions a liver can serve (in conjunction with other gastrointestinal organs and the inputs received by all of those organs) that you finally realise that you simply cannot detect nor capture all these functions even by the much larger nervous system of a dedicated scientist. The complexity is simply not capturable. Claiming that now you have studied the mechanisms of livers you can fully understand how livers function (or what they mean for the health of a patient) for all contexts across a patient's lifespan is naively reductionistic at best (carving nature at its joints; simplifying homogenising assumptions of component functionality) and arrogant malpractice that causes harm to patients' safety at worst.

Note: If you notice yourself feeling confused by these analogies, then this is a sign that you don't understand how the representational assumptions you are making about mechanistic interpretability are different than mine. That feels ambiguous because you are unable to sort the arguments I'm making into your current mental model of how individual components of a neural network function. I'm doing the best I can at explaining the difference in representation, but you will need to at least meet me in the middle to grog where I'm coming for.

(Another thing I realised here is that "filter toxins" is an abstraction of microscopic biological processes in aggregate that does not clarify in what contexts the liver filters out what kinds of toxins. Where does the liver malfunction for all possible "inputs"?)

> 3.: NNs are pretty alien, and so we will lack intuitions for interpreting them correctly.
R: Correct interpretation.

> 4.: Mechint doesn't yet deal with distribution shifts.
R: Correct interpretation.

> 5.: Interpretability assumes that we have the actual NN representation instead of just a binary representation, which would make the task even harder.
R: Not sure actually what you meant with this paraphrase.


On an overview of relevant theoretical limits

[12:36 pm, 10/11/2022] Remmelt:
Here is another overview I wrote recently, with points 1.-2. particularly relevant to whether simulating/detecting misalignment using mechanistic interpretability techniques is going to be sufficient for controlling the interactions of AGI internals with connected surroundings to prevent the build-up of human-species-wide lethal outside effects:



Returning to overarching points why mechanistic interpretability falls short

[12:36 pm, 10/11/2022] Remmelt:
Anyway, that’s a lot of stuff 🙂

[12:40 pm, 10/11/2022] Remmelt:
Just these two simple points above should already clarify why mechanistic interpretability falls short:

1. Computation is a tiny subset of internals’ interactions with connected surroundings; mechanistic interpretability focusses on reverse engineering computed code itself to understand the resulting digital outputs, but ignores further environmental interactions.

2. It would also be unsound to assume that natural abstractions of features (as tracking some of the regularities in the outside world) that can be mechanistically interpreted is all that matters to ensure long-term AGI safety.



On fundamental dynamics that are outside the scope of application of mechanistic interpretability

[9:32 am, 11/11/2022] Remmelt: 
> Thanks for the answer!
> I’m not sure I understand this fully.
> The following would be one interpretation
> that is part of my own model
> of why interpretability is difficult: [...]

Thank you for the paraphrases.

I like the ideas, but I do mean more fundamental dynamics that are in some sense simpler than what you came up with.

If you have an AGI model that is learning new internal ‘code variants’ (introducing variations on the parameters of functional code units, eg. of neural network weights and biases) then we are not only concerned with what the model is thinking or behaving internally. We are concerned with how the outputs of the model are processed through the wider environment (that includes other agents like humans observing the represented outputs somehow and acting on those outputs as a result).

And unfortunately, we cannot use mechanistic interpretability to detect how the outputs (computed by code unit variants in aggregate, contingent on the inputs) are going to be processed and passed on as effects within the wider environment. Nor is any other measurement or data processing technique going to be able to account sufficiently for how outputs are processed through connected surroundings of the environment (natural abstractions simply will not be able to capture all the complex dynamics taking place in that bigger environment).

That is, not sufficient to account for how external effects of the model’s operation will feed back into what sensor inputs the model might receive and in turn are transformed into new outputs, etc.

And also not how those external effects feed back into what (variants of) models even continue to physically exist (as configurations of a substrate) and function at increasing scale in the environment over time.


On whether I think mechanistic interpretability would be helpful at least

[9:40 am, 11/11/2022] Remmelt:
> Would you think it to be helpful at least? :)

Helpful for interpreting narrow AI.

For any AGI development, mechanistic interpretability will basically give false confidence to engineers that they would actually be able to sufficiently detect misaligned effects of AGI.

For the leaders of AGI R&D labs, mechanistic interpretability is a great marketing tool to show (visually) how their company is ‘ensuring’ their technology is ‘safe and aligned’. In other words, mechanistic interpretability will be used for ‘align-washing’ like how big fossil-fuel companies engage in green-washing.

Given that not having human society and the rest of our shared ecosystem destroyed seems like a priority above understanding and improving narrow AI, I have to conclude that current research efforts to do mechanistic interpretability are net really unhelpful.

AGI researchers and alignment researchers, can basically use it as a crotch to confirm that they can make progress (while missing/ignoring larger long-term problems).


[9:45 am, 11/11/2022] Remmelt:
BTW, I’m saying this because I want to be realistic and honest about what the current situation is, so we can act to safeguard life on Earth. I don’t mean to be cynical. I mean to clarify things that are constructive for finding an alternate path forward.

[9:47 am, 11/11/2022] Remmelt:
Also, it’s not fun to in effect tell people in your ingroup that the work they’re doing is useless for AGI safety. I’m really not personally benefiting from that, but it’s important to get clear here.



On ways the reverse-engineering analogy is unsound

[13:21, 11/11/2022] Remmelt:
> See the answer by Chris Olah here on his vision why the curse of dimensionality may not be unsurpassable: 

The problem IMO is that Chris Olah is making unsound representational assumptions (ie. unsound premises for how he can model interactions of code units) by comparing interpreting neural networks to reverse engineering code. Only at the end of his piece does he briefly mention the simplest least-hard-to-solve instance of the problem not addressed by his assembly-code reverse engineering analogy: polysemantic neurons. 

Before we can make progress in our conversation here, or in any other part of our conversation, I first have to clarify why I think you (or Olah, etc) are making unsound representational assumptions 

With the photograph vs. holograph analogy above, I tried to point at a different and IMO much more sound way of representing the functionality of code. But I get that this raises new questions about what definitions I'm using for terms, you want to precisely dig into the arguments step by step, etc. 

So for now, I'll just email you a more specific list of reasons why the reverse engineering analogy is unsound, and leave it at that.

{Emailed list:}
See below, only if you want to.
Note: I split sentences into lines
to make any claim or argument
more parsable step-by-step. 

   Let me clarify below reasons
   why I think Chris Olah's analogy between
   reverse engineering software binaries/assembly
   and mechanistic interpretability is unsound
   when it comes to whether and how
   one would sufficiently detect and correct 
   human-relevant errors in the code
   of large neural network architectures
   (particularly, any with general functionalities
    to enact changes in the global environment).

   What I meant to clarify here
   was that the way one would
   need to go about inspecting
   all the combinatorial complexity
   you would need to inspect
   to interpret the functions
   of NN-based architectures.
   (particularly those exhibiting
    general capabilities)
   is much different than 
   the way you would go about
   inspecting the binary/assembly code
   of some kind of large software stack
   running on a computer
   (based on my amateur understanding
    of what reverse engineering
    software code usually involves).

   1. Combinatorial complexity

   There seem to be many many 
   more degrees of freedom of interaction
   between all neurons (in/across layers) of an NN,
   then you can expect to see across
   the same amount of GB of binary code
   of some software program,
   which usually is much more constrained
   in terms of the number of interactions
   that are possible between possible elements
   above some threshold
   of negligible probability of the possibilities.

   Of course, if you look at software function calls,
   you can expect those to be reasonably complex as well
   (definitely not as complicated as neural networks,
     but a spaghetti nonetheless).

   But initialised and stochastically selected
   for collections of connected neurons are different
   to having explicitly coded for functions
   stored in particular parts of computer memory,
   (where there is going to be just *some* messiness
    around what functions/processes
    call what functions).
   For any prosaic NN-based AGI
   all of the stupendous number
   of neural network functions implementable 
   for all received inputs over time
   by all learned/selected internal code units
   through which human-relevant errors ('misalignments')
   could be caused in the outside world
   are just not trackable, by a very large margin.

   2. Possible meanings and functions

   As I tried to convey in the chapter 4,
   it is unsound to assume
   that a piece of a neural network
   represents a single meaning
   or causal function.

   Chris Olah briefly refers
   to polysemantic neurons in his piece.
   But, as an example,
   I think this *way* underplays
   the amount of complexity
   you have to deal with
   in order to interpret all possible
   'meanings' or 'functions' of a neural network
   for all possible inputs and outputs
   across all connected neurons
   of the neural network
     (going from first principles here;
     I'm not an ML engineer).

   I think that the following excerpt
   of Chris Olah's post very much
   understates the causal complexity
   involved in interpreting neural networks:
    "Computer programs
     often have memory layouts
     that are convenient to understand...
     Something kind of analogous to this
     often happens in neural networks.
     Let's assume for a moment
     that neural networks can be understood
     in terms of operations on a collection
     of independent "interpretable features".

   3. Human priors for code representation

   My impression is that for reverse
   engineering binary code,
   you are (usually) interpreting
   the binary code of functions
   explicitly programmed by human programmers
   that were compiled from one/a few
   of a finite set of programming languages.

   For interpreting pieces
   of a neural networks though,
   good practices and intuitions
   are clearly different
   than those used for
   interpreting binary code
   of software stacks.

   And unlike complicated functions
   programmed in by humans,
   this is complexity we are
   much less adapted to interpret,
   evolutionarily and culturally.

   We cannot assume somewhat
   static programming representations and heuristics
   that other computer programmers use
   who are also primate mammals
   that evolved roughly the same innate
   learning biases / core knowledge
   / psychological constraints
   (ie; innate priors
    for the perceiving and representation
    of observations as eg; bounded objects,
    sortable things and persons, etc).

   4. Input distribution shifts

   A major problem with mechanistic interpretability
   that I have not read Olah discuss online so far
   are input distribution shifts.

   Software models usually
   are constrained in their input sets.
   Input variables of software are
   usually symbolically standardised
   in ways that do not allow
   for random cross-overs
   in how the incoming data
   are processed internally.
   Neural networks definitely do
   get pseudo-random cross-overs
   in terms of how functional code units 
   (neurons in a given layer)
   process incoming data points.
   Neural networks
   (and other ML architectures)
   are in effect function approximators
   that select for 'transformation mappings'
   between an (assumed)
   probability distribution of inputs
   to resulting computed outputs.
   My impression is that 
   for most of the work Olah
   has been doing on
   mechanistically interpreting
   NN-based architectures
   that he implicitly relied upon that
   the distribution of probabilities of inputs
   would not shift significantly
   beyond used training datasets.
   Ie. Olah could just assume that
   internal neurons/circuits/etc
   will maintain roughly the same
   'range' of functionality given 
   that the inputs are not going 
   to shift 'too much'. 

   However, we really cannot assume
   that for any possible
   prosaic AGI architecture.

   Due to the implementation
   of more general functionalities,
   AGI would cause more
   widespread and bigger changes
   to ambient conditions and contexts
   of the global environment
   (which the architecture itself may
    be moving through and changing its
    input channels to over time). 
   Those changes would feed back
   through whatever connected
   input (sensor) channels of AGI
   and result in distribution shifts 
   of AGI's expressed functionality.

   So this gets back to chapter 1 and 2:
   optimisation methods can initialise and select for
   many different internal code unit variants
   (eg. of NN weights, circuits, sub-networks)
   that would within some assumed
   probability distribution of possible inputs
   function in *practically indistinguishable ways*
   (ie. not distinguished by mechanistic 
    interpretability techniques used by Olah).

   But once inputs go out of distribution.
   model functionality shifts as well,
   causing different outputs and outside effects.


   5. Starting at a higher layer of abstraction

   Finally, and actually
   not as relevant as the previous items,
   you also start inspecting neurons
   at a somewhat higher layer
   of abstraction
     (above matrix multiplications
     as corresponding with
     allowed biases of
     and weighted connections
     between neurons;
     and perhaps above some interfaces
     for distributed computation across servers
     over network/internet protocols)
   than for binary bits.

[21:15, 28/11/2022] Remmelt: 
> 1 seems overconfident to me. (But I must admit that for 1, I'm least certain if I understood what you meant)

R: Why specifically does this seem overconfident to you?

Is this a social argument based upon making social comparisons between me and mechanistic interpretability researchers who make different claims than I do?  Or do you have sound substantive reasons in mind why "a procedure would be able to represent all (human-survival-relevant) possible outcomes."?

> 2 seems true in a weak sense, meaning that I don't believe we will ever fully reverse-engineer any complicated NN and will remain "in the dark" about the meaning of some parts, similarly to how we don't fully understand the meaning of all parts of our DNA. I think it's overconfident to think that it's true in a way that will make mechint useless for AGI alignment.

R: Again, feel free to clarify what in your own mental model that would lead you to consider my claim (based on a different mental model) as overconfident.

> I don't share the intuition in 3. We choose NNs architecture and training process and will make them less alien by interpretability, and by a feedback loop, we may be able to find training processes and architectures that will lead to more interpretable models in the future.

R: I thought too this may be the case with narrow AI. Ie. people may come up with new good practices just as software developers did.  
---> How about for general AI?

> 4 seems correct, given my limited overview of what people are doing. [...]
> Similarly, I find it at least conceivable to have an NN that runs a "preserve human freedom and flourishing" algorithm that runs irrespective of the inputs and will try to keep things back on track, no matter what.

R: If you think its conceivable, how would you specifically go about conceiving this yourself? If you can't conceive of it yourself, how can you have any confidence in your sense that you can imagine that someone else would be able to conceive of such a neural network design in a technically sound way? Ie. sound in that their conception of the desiderata the NN design would meet does not actually fail to correspond with results from eg. complexity/computability theory, information theory or the underlying laws of physics?

> 5 is true, but doesn't seem a huge problem (as you also don't claim). After all, the researchers do have the NN in its abstract representation to work with, so they just don't have to deal with the increased difficulty.

R: Actually, the neural network will still be computed on underlying software/code layers, and the simplified abstraction of the neural network will not capture how the underlying software may cause neural networks to function differently, or how neural networks within prosaic AGI may modify underlying code layers that the computation of higher-level neural networks are dependent on.

The problem gets even worse for how hardware-substrate configurations affect the computation of software.


On destabilising internals–environment feedback loops 

[18:25, 28/11/2022] Remmelt:
> Okay, paraphrasing:
> -- The model will produce outputs.
> -- We will not know all effects of these outputs.
> -- These effects will change the environment,
> leading to changed inputs,
> which (if the parameters are still updated)
> leads to changed parameters
> in a way that cannot be predicted.
> I agree.
> That's pretty obvious
> and not yet a failure mode,
> but I will read on

This is a fine paraphrase of the first claim about destabilising feedback cycles that would magnify input distribution shifts and resulting shifts in the functionality of AGI:
"That is, not sufficient to account for how external effects of the model’s operation will feed back into what sensor inputs the model might receive and in turn are transformed into new outputs, etc."

{Later message: Ah, actually, the first claim about input-functionality shift feedback cycles is not just about learning different parameters with different inputs (although this is an important part, and I not thought about it yet for this specific dynamic).
It's mostly about inputs causing distribution shifts in outputs, which cause environmental effects that feed back as changes in (sensor) inputs.}

It does not cover the second claim, about substrate-needs convergence, which is what Forrest's {post-note: Forrest is a polymath and ex-Pentagon engineer, whose writing on AGI non-safety I edit} is about (the distribution-functionality shift feedback cycle is just one of a number of secondary dynamics that increase the speed of creep of AGI harmful effects):

"And also not how those external effects feed back into what (variants of) models even continue to physically exist (as configurations of a substrate) and function at increasing scale in the environment over time."

Defined succinctly, substrate-needs convergence is:
That any changing population of AGI parts
…that is, all manufactured/initialised components that are optimised for processing inputs into outputs such to in aggregate sense and act in many outside domains/context.
…converges on propagating environmental effects that fulfil their artificial needs
that is, effects that keep feeding back into a portion of those artificial parts continuing to exist, function, and scale up as configurations of a (solid-state) substrate.

What is similar about claim 1 and 2 is that both are about feedback loops from outputs of computed/operated AGI internal components to external effects propagating through the environment, and then back again to affecting the functioning and existence of AGI components. The distribution-functionality shift feedback cycle is something inspect internals methods cannot account for, so I shared it with you as an intuitive step-up analogy for explaining why substrate-needs convergence can also not be dealt with using inspect internals methods.


On why both "inspect internals" and "inspect externals" methods fall short

[18:30, 28/11/2022] Remmelt:
> I agree given the *premise*
> that mechint isn't helpful for AGI alignment,
> but don't yet see the reason for that premise

Mechanistic interpretability, as a technique for *inspecting internal components* for errors, cannot account for how the operation of AGI internal components causes outside effects propagating through the larger environment, and in turn feed back into the continued existence and functioning of some of those internal components, at increasing scales.

The scope of application of mechanistic interpretability is for *inspecting internals*, for errors that arise from *intrinsic selection of AGI code/hardware components through engineered optimisation methods*. It does not apply to *extrinsic* selection through effects across the wider environment. The scope of application of inspecting internals does not extend to the uncountable pathways through which AGI components' physical interactions loop back into the resulting selective continuity of existence, functioning and scaling of some of those components.

Code or hardware components do not intrinsically know what extensive causal history of prior physical interactions led to their current existence. You cannot "elicit" that knowledge from internal components, so you cannot detect errors resulting from extrinsic selection with internal inspection.

What's left is *external* inspection. Any implementable *externals* inspection/detection or modelling/simulation methods (or combinations thereof) will be *way too limited* in terms of capacity to detect misaligned self-substrate feedback loops in the interactions of AGI's changing internal components through changing available signalling channels with changing connected surroundings of the environment, over the long term.

So if external inspection methods are not going to cut it (to prevent AGI convergence on ecosystem-wide extinction), and the use of internal inspection methods' cannot functionally replace the use of external inspection methods (as outside the scope of application), then mechanistic interpretability as a method for internal inspection is simply not going to help with making AGI safe over the long run.

Specific inequalities you may want to dig into for grogging this abstract argument:
1. why no short-cut algorithm can assess the behavioural properties (digital outputs) of the, for practical purposes, arbitrary algorithms introduced internally by self-modifying AGI (analogous to Rice Theorem result).

2. why chaotic dynamics (non-linearly amplifying feedback cycles of potentially smaller-than-measurable localised effects) and complex dynamics of (the expression of multiple functional effects of) parts of a system are unpredictable and unsimulatable respectively, yet can still robustly lead to changes to the agent's body and environment (in eg. the expression of DNA code of biological organisms into adaptive phenotypic effects).

3. why aligning the external functioning of AGI internal components involves sensing relevant effects in the larger and more complex outside environment, and compressing that data in some *lossy* way to compare it against alignment references.



On neural network code as spaghetti code

[20:15, 28/11/2022] Remmelt:
> Ah, I see you using the term spaghetti code btw.
> Note that most people wouldn't
> call neural networks "spaghetti code",
> they mean hand-written unmaintainable code with it.
> (Just saying it in case
>  it may help for avoiding confusions)

Thanks for the thought. I agree that's how the term "spaghetti code" is often used in context currently, so that might be a little confusing at first. As far as "spaghetti code" is defined literally as "unstructured and difficult-to-maintain source code", I think the term can be used in the contexts of neural network code too.

This conveys a big concern of neural networks – AI developers are prepared to deploy code for real-world use that is so messy to the point that no professional-minded software developer would accept such code from their colleague. Particularly for safety-critical applications that would amount to gross misconduct. It's a reason I hear why many industrial engineers have not switched from eg. decision tree algorithms to neural networks, despite the AI hype and benefits AI developers say their architectures have for being applied everywhere.


Returning to the reverse engineering analogy

[21:25, 28/11/2022] Remmelt:
> In general, most of the points seem
> some variant of
> "The following aspect of mechint seems really hard",
> and people may agree with that
> and view these as core difficulties,
> and I may even agree that
> they are not discussed enough publicly.
> (I wouldn't claim that researchers
>  don't have these points in their internal models
>  of difficulties to be overcome --
>  there is only so much that researchers
>  can write down and express in a given day).

These are reasons that clarify why Olah's explanation of the reverse engineering analogy falls way short of capturing the complexity and risk of false negatives when inspecting large neural networks for human-relevant errors (misalignments).

If Olah already has any of these points as part of his mental model, then it is his responsibility to properly describe them in his writing, even briefly if he has other legitimate priorities, rather than sum up all the reasons why mechanistic interpretability is a problem that is the same kind of hard as interpreting the assembly code of software.

Note that any mistake of omitting a crucial aspect here can *lead to everyone dying down the line*.

If a surgeon inspecting the components of your body missed a crucial aspect in interpreting what your organs do, resulting in your death some years later, would you see that as acceptable professional conduct? What about a surgeon forgetting to teach crucial aspects of organ functioning to trainees in online documentation?

Analogously, can we just say, "oops, oh yeah me being overly optimistic about our ability to interpret internal components led to the death of billions of people down the line"?


[21:28, 28/11/2022] Remmelt:
> None of the points seem to destroy
> the prospect of any value to be gained from mechint
> for the alignment of AGI.

At the least, they result in a conclusion that the expected value is much lower than expected before.
If the prospect of mechanistically interpreting AGI internals comprehensively to prevent ecosystem-wide extinction turns out a lot more pessimistic than thought earlier, that means the expected value of working on mechanistic interpretability is also much lower.



On the key sub-arguments for why long-term safe AGI is not possible

[21:34, 28/11/2022] Remmelt:
> Can you maybe mention the single,
> in your view strongest, argument
> that tries to make alignment of advanced AI
> impossible or extremely unlikely?
> Maybe you mentioned it already above
> in the parts of your second to last message stream
> which I ignored, then you can also point me to it.

If you want the conclusive argument, this requires understanding three key sub-arguments first.

One sub-argument is about theoretical limits of engineerable control, so perhaps you can start there?

The other two sub-arguments are about:
- economic decoupling of AI exchanges of value from human exchanges of value.
- substrate-needs convergence (as distinct from but enabled by instrumental convergence).



On ecosystems being uncomputable

[22:14, 28/11/2022] Remmelt:
> This seems similar to some of your concerns
The post "The limited upside of interpretability" is excellent btw.
Just reading through, thank you.

One claim I think is not capturing ecosystem complexity right is the computational irreducibility point.
Flawlessly (ie. deterministically) computing an algorithm that has the shortest length (equivalent to Kolmogorov Complexity) of any algorithm that produces its outputs is *computationally irreducible* in the sense that you cannot just run a shorter-length algorithm requiring fewer computational operations to replace it.

An ecosystem (whether based around carbon-centered DNA/RNA or solid-state-lattice-embedded-transistors) is *uncomputable*. This is because part interactions within that ecosystem do involve noise interference at various levels, that feed chaotic dynamics that in turn result in new formation of structure/parts. You simply cannot scan the parts of that ecosystem and simulate it faithfully on the equivalent of a Turing machine.

You can make some higher-level predictions about long-term convergent outcomes of that ecosystem (as Forrest is doing, for parts of the human-carbon ecosystem in interactions with parts of the AI-solid-state ecosystem).



Polymath researcher's response on theoretical limits of engineerable control

[09:51, 29/11/2022] Remmelt:
Regarding theoretical limits of engineerable control,
Forrest {post-note: Forrest is the original researcher)
just emailed me this:

“For the aspect that has to do with technical 
non-alignment, the key info is the following:.

 - that any and every AGI 'safety/alignment' process
 is a special case of a 'causative feedback process'.
   - that there are no/zero exceptions to this truth.
   - as anything and everything that is true of 
   the use of causation, as a feedback process, 
   and/or an 'algorithm', also as a 'modeling process',
   and/or of 'signaling', inherent in any 'feedback',
   will for sure be true also of any AGI safety/alignment
   technique, method, proposal, methodology, algorithm, etc.

 - that any and every 'causative feedback process'
 depends on at least all of the following:.

   - 1; the completeness of the sense input.
     - as the input data that is being processed by 
     or used by, the proposed AGI alignment technique/etc,
     and also as the input data that is intake into 
     the AGI system, so that the model of the key aspects
     of the AGI system has reasonably correct input data.

   - 2; the completeness of process modelability.
     - ie; that the proposed AGI alignment technique/etc,
     has to actually be that, some sort of algorithm,
     itself conditional on only causation and logic
     and that the AGI system itself has to be 
     at least partially modelable, in whatever key
     aspects, are necessary to establish 'alignment'.
   - 3; the completeness of predictability.
     - ie; as the assumption that the model 
     of the AGI system 
     when also given the model of the input data
     will allow for sufficient predictability
     of whatever key aspects of the future AGI outputs
     will be, before the real (non-modeled) AGI 
     would actually act, in a way that is assessable
     and comparable to desired outcome states.

   - 4; the completeness of some type of a comparison 
   to a reference (where that reference implicitly defines 
   whatever is the meaning of "aligned" or "safe").

   - 5; the completeness of some type of signaling 
   (ie; what is the "feedback", how the model itself
   works internally, how the model alerts the actuator
   so that the model 'controls' and constrains the AGI 
   so that it is acting/operating in an aligned way).

   - 6; the completeness of some type of 
   conditionalization (ie, what is "effectiveness")
   of at least one of 
   the following AGI aspects:.
     - output actions.
     - internal process.
     - sense input.

    - ie; where/if the AGI conditionalization 
    does not have sufficient "power" to actually constrain
    the AGI from doing bad things, then even a very good
    alignment algorithm/technique/process will not result
    in an aligned/safe AGI.

 - that aspects 1 thru 6 (inclusive) are true of any 
 and every 'causative feedback process'.
   - that there are exactly none/zero exceptions.
   - that all causative feedback process 
   will have/require all six of these aspects 
   (with no exceptions).

 - that therefore, a/the/any/all AGI alignment/safety
 enforcement protocols, techniques, methodologies, etc,
 will also (for sure) be required to have and implement 
 all six aspects (with no exceptions), 
 and, where given that requirement, 
 if any of these six aspects, for whatever reason, 
 cannot be implemented, then that/therefore 
 AGI alignment/safety cannot be implemented.

 Unfortunately, every single one of the listed 
 dependencies (all six of them) are individually impossible 
   (ie; cannot be 'complete enough' to achieve 
   anywhere near the minimum threshold necessary).
 Insofar as all six are necessary together 
 to achieve AGI alignment, that there are effectively six, 
 at least semi-independent, arguments against 
 there being any notion of AGI alignment, 
 as based on nothing outside fo the notions of
 causation, conditionalization, and/or logic
 (ie, all different manifestations of the same idea).

 Moreover, the control and/or "error correction" system 
 must itself not make mistakes/errors (ie, be/operate
 within reasonable limits, be itself predictable, etc). 
 What tracks errors/mistakes in the system 
 that is modeling the system to apply error correction to?  
 Insofar as the same logic applies in proportion to the
 complexity of the error correction, as it does in the
 complexity of the AGI system itself, then there is a 
 kind of regression cascade problem.”



Polymath researcher's response on mechanistic interpretability

[09:51, 29/11/2022] Remmelt:
And on mechanistic interpretability:
"Maybe 'mechanistic interpretability' arguments
always ends up confusing things in regards to 
the argument of AGI safety impossibility?

The notion that might make some of this easier
is to describe it as "dual use functionality"
that occurs at the small scale, in a distributed way,
and which will eventually result in unexpected
shifts in macroscopic results/outcomes.

No one bothers to try to 'observe' and 'interpret
or describe the meaning/function of', or outcome, 
of what is happening in the small details 
in any NN or system.  Hence, subtle exogenously
coordinated shifts occurring everywhere at once
will routinely get overlooked.

'Mechanistic interpretability' frames things in
terms of single macroscopic functions/descriptions.
That leads to a confusing focus, insofar as people
believe that is the only way to think about it.
Our work is about functions with plural microscopic
drivers/outcomes, and what sort of implications 
that has.”

Afterward, an email response from the polymath researcher

Hi Remmelt,

I liked your rebuttal of mechanical interpretability {here}.  Was clear and effective. I noticed that it can be stated as a component of the overall path of the argument of "That any AGI existence is inherently incompatible with any reasonable notion of AGI Safety". The path can maybe be expressed as below.
Perhaps it will be helpful?


~ ~ ~

- Where all methods of 'safety' implicitly include the notion of "not resulting in everyone (all life) being prematurely dead in the long term"; 
- and where any meaningful version of 'Safety', as a concept, depends on at least some strong notion of 'alignment'; 
- and where any and all notions of 'alignment' depends on (cannot not depend on) some sort of internal error correction algorithm, or some sort external 'incentivize pressure', or some combination of only these two kinds of 'alignment forces';. 
- and where all error correction algorithms depend on some sort of notion of mechanistic interpretability;. 
- and where it has been shown that AGI will result in the premature death of all humans, in the long term, via the substrate-needs convergence process;. 
- and that such no form of mechanistic interpretability can be used to stop or reverse substrate-needs convergence;. 
- that/hence mechanistic interpretability cannot be used to implement the kind of error correction needed for alignment, which is itself needed for safety. 
- ...
- ...
- ...

New Comment
9 comments, sorted by Click to highlight new comments since:

Analogously, someone could write "antibiotics are a non-starter because lots of infections aren't even bacterial." That would be pretty uncompelling to someone who thought that bacterial infections were a major risk.

The fact that an approach doesn't solve all problems doesn't mean it "does not and cannot contribute to long-term safety," that seems hyperbolic and kind of ridiculous.

Another reason: internals may not strongly indicate what an agent is ultimately trying to do.

Thanks, will read!

I'm afraid I won't have time to read this entire post. But since (some of) your arguments seem very similar to The limited upside of interpretability, I just wanted to mention my response to that (I think it more or less also applies to your post, though there are probably additional points in your posts that I don't address).

I read your comment before. My post applies to your comment (course-grained predictions based on internal inspection are insufficient).

EDIT: Just responded: Thanks for bringing it under my attention again.

This post argues that mechanistic interpretability's scope of application is too limited. Your comment describes two misalignment examples that are (maybe) within mechanistic interpretability's scope of application.

Therefore, this post (and Limited Upside of Interpretability) applies to your comment – by showing the limits of where the comment's premises apply – and not the other way around.

To be more specific
You gave two examples for the commonly brought up cases of intentional direct lethality and explicitly rendered deception: "is it (intending to) going to kill us all" and "checking whether the AI is still in a training sandbox...and e.g. trying to scam people we're simulating for money".

The two examples given are unimaginative in terms of how human-lethal misalignment can (and would necessarily) look like over the long run. They are about the most straightforward AGI misalignment scenarios we could wish to detect for.

Here are some desiderata those misalignment threats would need to meet to be sufficiently detectable (such to correct them to not cause (a lot of) harm over the long run):

  1. Be fully explicitly represented (at least as a detectable abstraction that is granular enough for the misalignment to be correctable) by code within the AGI. Ie. the misaligned outcomes are not manifested implicitly as a result of the specific iterated interactions between the changing AGI internals and changing connected surroundings of the (more dynamically complex) environment.
  2. Be compressible in their fine-grained characteristics (code parameters, connectivity, potential/actual inputs over time, all possible output channels of influence on the environment) such for relevant aspects not to be filtered out by the necessarily lossy data-compression processes of the mechanistic interpretability system, such to be comparable and "alignable" against higher-level reference values across semantic dimensions relevant to human safety.
  3. Be detected at a virtually 100% false negative rate across all instances of those particular kinds of misalignment over the long term.
  4. Be complicated mechanistically, but not chaotically complex. Ie. not causing of emergent dynamics that destabilise environmental conditions yet are not granularly predictable enough to prevent.
  5. Be less complicated to model (sufficiently to simulate and prevent/correct the misalignment) than how complicated the mechanistic interpretability system is or has the capacity to be (by Good Regulator Theorem).
  6. Not be instantiated by a self-modifying AGI, where given the eventual NP computational complexity of subsets of the initialised, optimised for, connected up and physically enduring code that are computed in physical interactions with the changing connected surroundings of the environment, the long-term outside effects of that code are actually unpredictable for the vast majority of human-safety-relevant aspects. Like how Busy Beaver functions are almost completely unpredictable in their outputs without fully computing their code ahead of time, and like how evolving biological systems are even less predictable in their physical behaviour over time. 

Perhaps you can dig into a few of these listed limits and come back on this?

1. Non-Distinguished Internal Code Variants

Maybe related: 

There's a lot here, some of it relevant to mechanistic interpretability and some of it not. But addressing your actual specific arguments against mechanistic interpretability (ie this section and the next), I think your arguments here prove far too much.

For example, your reasoning on why mech interp is a non-starter ("what matters here is the effects that the (changing) internals’ interactions with connected surroundings of the environment have") is true of any essentially computer program with inputs and outputs. Of your specific arguments in the next section, at least arguments 1, 3, 5, 8, 9, and 10 (and arguably 2, 4, 6, and others) apply equally to any computer program.

Since it's implausible that you've proved that no computer program with inputs and outputs can be usefully understood, I think it's similarly implausible that you've proved that no neural network can be usefully understood from its internals.