id stringlengths 36 36 | source stringclasses 15 values | formatted_source stringclasses 13 values | text stringlengths 2 7.55M |
|---|---|---|---|
77cdab61-64c7-400e-9546-f1c1433eb046 | trentmkelly/LessWrong-43k | LessWrong | When will total cases in the EU surpass that of China?
Pretty much says it all. Bloomburg show the count for Europe as 64 thousand and doesn't look like the curve is ready to level off.
Do people think a couple of days for Europe to exceed China's (near 81,000) or more?
The follow up is what will be the total? |
6b103c5b-ca25-47d5-9dca-48fb81f1a5d1 | StampyAI/alignment-research-dataset/lesswrong | LessWrong | Decision Theories: A Semi-Formal Analysis, Part I
Or: The Problem with Naive Decision Theory
------------------------------------------
**Previously:** [Decision Theories: A Less Wrong Primer](/lw/aq9/decision_theories_a_less_wrong_primer/)
**Summary of Sequence:** *In* *the context of a tournament for computer programs**, I give almost-explicit versions of causal, timeless, ambient, updateless, and several other decision theories. I explain the mathematical considerations that make decision theories tricky in general, and end with a bunch of links to the relevant recent research. This sequence is heavier on the math than [the primer](/lw/aq9/decision_theories_a_less_wrong_primer/) was, but is meant to be accessible to a fairly general audience. Understanding the basics of [game theory](http://en.wikipedia.org/wiki/Game_theory) (and [Nash equilibria](http://en.wikipedia.org/wiki/Nash_equilibrium)) will be essential. Knowing about things like [Gödel numbering](http://en.wikipedia.org/wiki/G%C3%B6del_numbering), [quining](http://en.wikipedia.org/wiki/Quine_%28computing%29) and [Löb's Theorem](/lw/t6/the_cartoon_guide_to_l%C3%B6bs_theorem/) will help, but won't be required.*
**Summary of Post:** *I introduce a context in which we can avoid most of the usual tricky philosophical problems and formalize the decision theories of interest. Then I show the chief issue with what might be called "naive decision theory": the problem of spurious counterfactual reasoning. In future posts, we'll see how other decision theories get around that problem.*
In my [Decision Theory Primer](/lw/aq9/decision_theories_a_less_wrong_primer/), I gave an intuitive explanation of decision theories; now I'd like to give a [technical explanation](http://yudkowsky.net/rational/technical). The main difficulty is that in the real world, there are all sorts of complications that are extraneous to the core of decision theory. (I'll mention more of these in the last post, but an obvious one is that we can't be sure that our perception and memory match reality.)
In order to avoid such difficulties, I'll need to demonstrate decision theory in a completely artificial setting: a tournament among computer programs.
You're a computer programmer entering a tournament for spectacular stakes. But you won't be competing in person: instead, you'll be submitting code for a program to represent you, and that program will be competing one-on-one with other programs in a series of games.
You don't know what the specific games are, but the contest has specified some ground rules:
* In each game, your program and its opponent will have to choose separately between several options. (There are independent sources of randomness available to each program, so [mixed strategies](http://en.wikipedia.org/wiki/Strategy_%28game_theory%29) are legal.)
* The games are pure strategic conflicts: the expected payouts to *each* programmer depend on the outputs of *both* programs, and can be calculated simply if you know those outputs. (In particular, you can represent each game as a [payoff matrix](http://en.wikipedia.org/wiki/Normal-form_game) in terms of the programs' outputs.) For example, your program might play the [Prisoner's Dilemma](http://wiki.lesswrong.com/wiki/Prisoner%27s_dilemma) against another program.
* Both programs have access to the source code of *each other* and of the game they're playing.
* The programs don't get to carry any memories from round to round, or modify their source code at any stage. (This makes the analysis *much* simpler, and makes it even more impressive if we find unexploitable programs which are capable of mutual cooperation.)
* While many of the programs were written by other programmers trying to win prizes for themselves, there are also some special algorithms included to test your reactions; for example, there could be programs that always cooperate in the Prisoner's Dilemma, or an instance of [Newcomb's Predictor](http://wiki.lesswrong.com/wiki/Newcomb%27s_problem).
* The tournament may also include some exact copies of your own program, but *you* won't get any of the prizes won by these extra copies, only the prizes won by your actual entry. (There's no way for your program to distinguish whether it's the original or a copy.)
* There are more than enough prizes to go around, so you don't have to make anyone else lose, you just want your program to win as much as it can.
* Also, there will be enough games played that most of the variance should wash out, so you should aim for the highest expected value per round rather than worry about the [concave utility](http://en.wikipedia.org/wiki/Risk_averse#Utility_of_money) of more prizes.
So, what kind of program should you write?
In the next few posts, we'll examine several ideas, problems and decision theories, increasing our sophistication as we go. We'll use **X** to denote your program, and *x1*, . . . , *xn* to denote its possible outputs; likewise, your opponent in the current round is **Y** with possible outputs *y1*, . . . , *ym*. We'll let **U**(*xi*,*yj*) denote the resulting payout to you if **X** outputs *xi* and **Y** outputs *yj*.
### Idea 1: Play defense with a Nash equilibrium
In our example, we know what utility function the opponent should have: its own expected payout.[0](#utilities) Any such game has at least one [Nash equilibrium](http://en.wikipedia.org/wiki/Nash_equilibrium), a pair of strategies (which may be [mixed](http://en.wikipedia.org/wiki/Mixed_strategy#Mixed_strategy)) such that if **X** and **Y** both adopted them, then neither would be better off unilaterally switching strategies. In that sense, at least, if **X** plays a Nash equilibrium, it can be sure of not being exploited by **Y**. (In particular, **X** will never end up tricked into cooperating in the Prisoner's Dilemma while **Y** defects.)
Of course, there may be more than one Nash equilibrium in a game, and these may be of unequal value if the game is non-zero-sum. ([Coordination problems](http://en.wikipedia.org/wiki/Coordination_game) are tricky in general.) So this is underspecified; still, choosing an arbitrary Nash equilibrium is a decent backup strategy. But we can often do better:
### Idea 2: Inference
The most basic intuition a human being has in this situation is to start trying to deduce things about **Y**'s output from its source code, or even deduce things directly about **U**. This idea is best illustrated by playing Rock, Paper, Scissors against [a player who always throws Rock](http://www.youtube.com/watch?v=NMxzU6hxrNA): if you figure this out, then you should of course play Paper rather than the Nash equilibrium of 1/3 Rock, 1/3 Paper, 1/3 Scissors. (And in a coordination game, you'd prefer to settle on the *same* Nash equilibrium that **Y** outputs.)
Automating inference is [an exceedingly difficult problem in general](http://en.wikipedia.org/wiki/Automated_reasoning), though researchers have made substantial progress. All the decision theories we'll talk about will include some sort of "inference module", which can be applied to the source code of **Y** to deduce its output, applied to the code of the full round (including **X**, **Y**, and the payoff matrix) to deduce the value of **U**, etc.
### Problem: You can't deduce everything
[Gödel's First Incompleteness Theorem](http://en.wikipedia.org/wiki/G%C3%B6del%27s_incompleteness_theorems) and the [Halting Problem](http://en.wikipedia.org/wiki/Halting_problem) both imply that it's impossible to write a program that correctly deduces *in general*[1](#ingeneral) the output of arbitrary other programs. So we have to be prepared for our inference module to fail sometimes.
A well-written inference module will either return a correct answer for a question or return "Unknown"; a sloppily-written module can get stuck in an infinite process, and a badly-written one will return an incorrect answer sometimes. It should be clear that we'll want our inference module to be of the first sort.
It seems we have enough already to define our first candidate decision theory:
### Naive Decision Theory
Let's first consider the approach that seems most obvious. Since we know the source code of the entire round (including **X** and **Y**), we could implement the following program:
* For each *xi*, assume the output of **X** is *xi*, and try to deduce the expected value of **U**. (That is, try and deduce statements of the form "if (output **X**)=*xi* then **U**=*ui*" for some *ui*).
* If this succeeds for each *xi*, output the *xi* for which *ui* is the largest.
* If this does not succeed for some *xi*, output a Nash equilibrium strategy.
This "naive decision theory" certainly qualifies for our tournament; it may be a bit trickier to write an inference module that does an open-ended search for the value of **U**, but it's not impossible (since human mathematicians solve open-ended deduction problems all the time). And it looks like the worst-case scenario is a Nash equilibrium, not total exploitation. What could possibly go wrong?
### Problem: Beware self-fulfilling prophecies!
There's a reason that we don't normally ask an automated theorem prover to consider questions about its *own* mathematical structure: if we ask the question in a certain way, [any choice becomes a self-fulfilling prophecy](/lw/t8/you_provably_cant_trust_yourself/).
If **X** deduces its own output by a valid process, then it's created a self-fulfilling prophecy for its output, and the problem with *that* is that a bad self-fulfilling prophecy is just as consistent as a good one. If we want to use statements like "if (output **X**)=*xi* then **U**=*ui*" to make our final choice, then we have to beware the other half of logical implication, that "not P" implies "if P then Q". This allows for what we might call *spurious counterfactuals*, which can throw off the actual decision in a perfectly self-consistent way.
Consider, for example, the one-player game where **X** gets $1 for outputting *a*, or $10 for outputting *b*. We want **X** to do the following:
* Prove "if (output **X**)=*a* then **U**=1"
* Prove "if (output **X**)=*b* then **U**=10"
* Output *b*.
But it's just as consistent for **X** to do the following:
* Prove "(output **X**)=*a*"
* Prove "if (output **X**)=*a* then **U**=1"
* Prove "if (output **X**)=*b* then **U**=0"
* Output *a*.
How could that possibly work? Since (output **X**)=*a*, the third line is a true logical statement! It's like the fact that [you can prove anything if you assume a falsehood](http://xkcd.com/704/) (though rather than unconditionally accepting a false premise, **X** is using a false premise as the antecedent of a [material conditional](http://en.wikipedia.org/wiki/Material_conditional)). In this example, the very order in which **X** looks for proofs (which is part of the definition of **X**) affects which counterfactuals **X** can and cannot prove. (One important thing to note is that **X** *cannot* prove a spurious counterfactual about the action that it *does* output, only about the ones that it doesn't!)
I don't need to tell you that the second chain of proofs is *not* what we want **X** to do. Worse, if this is a real bug, then it could also be an *exploitable vulnerability*: if your source code for **X** were released in advance of the tournament, then other programmers might write programs that cause **X** to generate spurious counterfactuals for all but the moves that are most favorable to **Y**.
### Can NDT be salvaged?
Let's consider some quick fixes before we give up on Naive Decision Theory.
Can we simply prohibit **X** from ever deducing "(output **X**)=*xi*" as a step? This doesn't work because of the possibility of indirect self-reference; **X** could end up deducing some seemingly innocuous statements which happen to correspond to its own [Gödel numbering](http://en.wikipedia.org/wiki/G%C3%B6del_numbering), and the spurious counterfactuals would follow from those- without **X** ever having noticed that it had done anything of the sort. And it's provably impossible for **X** to recognize every possible Gödel numbering for its own inference module!
Next, it might seem like an inference module should stumble on the "genuine" counterfactuals before running into spurious ones, since the "genuine" ones seem necessarily simpler. However, it turns out ([as proved by cousin\_it](/r/discussion/lw/b5t/a_model_of_udt_with_a_malicious_proof_searcher/)) that one can write a valid but malicious inference module which returns and acts on a spurious proof, and ([as proved by gRR](/lw/b5t/an_example_of_selffulfilling_spurious_proofs_in/67bx)) that a game with malicious code can similarly dupe a NDT agent with a good inference module!
Lastly, it seems safer to deduce counterfactuals "if (output **X**)=*xi* then (output **Y**)=*yj*" and apply the **U**(*xi*,*yj*) afterwards. And indeed, I can't see how to make **Y** exploit **X** in a straight-up Prisoner's Dilemma if that algorithm is used. There are still two problems, though. First, this algorithm now depends on the values **U**(*xi*,*yj*) being given to it by authority- it can't safely deduce them from the source code for the game. And secondly, it could two-box on Newcomb's Problem and defect against itself in the Prisoner's Dilemma if it finds spurious counterfactuals there.
Thus it seems we'll need to do something substantially different.
### Well, now what?
There are several ways we could write a decision theory to do inference without risking spurious counterfactuals, and indeed the decision theories we discuss on Less Wrong correspond to different valid approaches. The differences in their decisions come not from better-written inference modules, but from more effective strategies for using their inference module. In the posts to come, I'll show you how they work in detail.
**Next:** [Part II: Causal Decision Theory and Substitution](/lw/az6/decision_theories_a_semiformal_analysis_part_ii/)
### Notes:
**0.** Things get wacky if we don't know the utility function of the opponent; fortunately, even the special cases like Newcomb's predictor can be expressed as expected utility maximizers for some payoff matrix (in this case, one where the predictor gets rewarded when it matches your decision exactly).
**1.** That "in general" is important: it's quite possible to write programs that deduce the outputs of plenty of other programs. It just so happens that there's always some program that your inference module will fail on. The [classic way to generate a failure case](http://en.wikipedia.org/wiki/Cantor%27s_diagonal_argument) is to run the inference module on a modified version of itself, such that returning a correct answer would induce a contradiction. This isn't just a hypothetical disability: if **X** is trying to deduce the output of **Y** in this round, and **Y** is trying to deduce the output of **X** in this round, then we might have exactly this problem! |
e481daa0-1b3a-4105-a05e-9c78f4a8349e | trentmkelly/LessWrong-43k | LessWrong | U.S. Government Seeks Input on National AI R&D Strategic Plan - Deadline May 29
(Post written by Claude Opus)
The National Science Foundation is requesting public input on updating the National AI Research and Development Strategic Plan, following President Trump's Executive Order 14179 on AI leadership.
What they're looking for: Federal R&D priorities for AI over the next 3-5 years, specifically in areas where private sector investment is insufficient due to lack of immediate commercial returns.
Relevant focus areas include:
* Fundamental advances in AI algorithms and mathematical foundations
* AI standards, security, and reliability research
* AI for accelerating scientific discovery
* Human-AI interaction
* AI systems capable of reasoning and robustness in dynamic environments
* High-risk, high-reward AI research for future U.S. competitiveness
Why this matters: This is an opportunity to influence government funding toward AI safety, robustness, and beneficial AI research - areas often underfunded by industry due to lack of immediate profit potential.
Submission details:
* Deadline: May 29, 2025 (11:59 PM ET)
* Submit at: https://www.federalregister.gov/documents/2025/04/29/2025-07332/request-for-information-on-the-development-of-a-2025-national-artificial-intelligence-ai-research
* Length: Ideally 2 pages, max 10 pages
* Must include:
* Responses must include the name of the person(s) or organization(s) filing the comment and the following statement: “This document is approved for public dissemination. The document contains no business-proprietary or confidential information. Document contents may be reused by the government in developing the 2025 National AI R&D Strategic Plan and associated documents without attribution.”
Note: The plan explicitly mentions "promoting human flourishing" as a goal alongside economic competitiveness and national security, suggesting openness to perspectives on beneficial AI development.
This represents a concrete opportunity for the EA / Less Wrong community to shape government AI resea |
6de32a91-7f5c-42f6-9f00-ad4e2c46acef | StampyAI/alignment-research-dataset/lesswrong | LessWrong | [ASoT] Reflectivity in Narrow AI
*I wrote this a month ago while working on my SERI MATS applications for shard theory. I'm now less confident in the claims and the usefulness of this direction, but it still seems worth sharing.*
I think reflectivity happens [earlier then you might think](https://www.lesswrong.com/posts/k4AQqboXz8iE5TNXK/a-shot-at-the-diamond-alignment-problem?commentId=Li9gt3XmjDiEmhwHN) in embedded RL agents. The basic concepts around value drift ("addiction", ...) are available in the world model from pretraining on human data (and alignment posts), and modeling context dependent shard activation and value drift helps the SSL WM predict future behavior. Because of these things *I think we can get useful reflectivity and study it in sub-dangerous AI.* This is where a good chunk of my alignment optimism comes from. (understanding reflectivity and instrumental convergence in real systems seems very important to building a safe AGI.)
In my model people view reflectivity through some sort of magic lens (possibly due to conflating mystical consciousness and non-mystical self-awareness?). Predicting that I'm more likely to crave cookie after seeing cookie or after becoming hungry isn't that hard. And if you explain shards and contextual activation (granted understanding the abstract concepts might be hard) you get more. Abstract reflection seems hard but still doable in sub AGI systems.
There's also a meaningful difference between primitive/dumb shard, my health shards outmaneuver my cookie shards because the former are "sophisitcated enough" to reflectively outsmart the cookie shards (e.g. by hiding the cookies) while the latter is contextually activated and "more primitive". I expect modelling the contextual activation of the cookie shard not to be hard, but reflective planning like hiding cookies seems harder- though still doable. (This might be where the majority of the interesting/hard part could be.) |
b6f2ba84-decb-4e62-818e-a832ad732a24 | trentmkelly/LessWrong-43k | LessWrong | The Proof of Doom
Epistemic Status: Ravings
Importance: Easily the most important problem in the world. If we can escape the proof of doom, we will likely also solve all our other problems as a side effect, and all that remains will be the fundamental limits. Our new questions will be things like "How much joy can the universe physically support?"
-
It seems to me that the world, and everyone in it, is doomed, and that the end is considerably nigher than I might like.
To be more specific, I think that we may well create an Artificial General Intelligence within around 20 years time, and that that will be our last act.
The newly-created AGI will immediately kill everyone on the planet, and proceed to the destruction of the universe. Its sphere of destruction will expand at light speed, eventually encompassing everything reachable.
There may well be more proximal threats to our species. Comets are one obvious one, but they seem very unlikely. Artificially created universally fatal plagues are another, but perhaps not very likely to happen within the next twenty years.
--
I've believed this for many years now, although my timescales were longer originally, but it seems to me that this is now becoming a common belief amongst those who have thought about the problem.
In fact, if not consensus, then at least the majority opinion amongst those mathematicians, computer scientists, and AI researchers who have given the subject more than a few days thought.
Those who once were optimistic seem pessimistic now. Those who were once dismissive seem optimistic.
But it is far from being even a mainstream opinion amongst those who might understand the arguments.
Far, even, from rising to the level of a possible concern.
Amongst my personal friends, amongst people who would mostly take my word on technical and scientific issues, I have found it impossible to communicate my fears.
Not all those who are capable of pressing the suicide button understand that there is a suicide button.
-- |
5438d3b3-48c9-4a18-b298-1298d08e28af | StampyAI/alignment-research-dataset/blogs | Blogs | an Evangelion dialogue explaining the QACI alignment plan
*this post was written by [Tamsin Leake](https://carado.moe) at [Orthogonal](https://orxl.org).*
*thanks to [Julia Persson](https://www.lesswrong.com/users/juliahp) and [mesaoptimizer](https://mesaoptimizer.com/) for their help putting it together.*
an Evangelion dialogue explaining the QACI alignment plan
---------------------------------------------------------
this post explains the justification for, and the math formalization of, the [QACI](qaci.html) plan for [formal-goal alignment](formal-alignment-theory-change.html). you might also be interested in its companion post, [*formalizing the QACI alignment formal-goal*](qaci-math.html), which just covers the math in a more straightforward, bottom-up manner.
#### 1. agent foundations & anthropics
🟣 ***misato*** — hi ritsuko! so, how's this alignment stuff going?
🟡 ***ritsuko*** — well, i think i've got *an idea*, but you're not going to like it.
🟢 ***shinji*** — that's exciting! what is it?
🟡 ***ritsuko*** — so, you know how in [*the sequences*](https://www.readthesequences.com/) and [*superintelligence*](https://publicism.info/philosophy/superintelligence/index.html), yudkowsky and bostrom talk about how hard it is to fully formalize something which leads to nice things when maximized by a utility function? so much so that [it serves as an exercise to think about one's values](core-vals-exist-selfdet.html) and [consistently realize how complex they are](https://www.lesswrong.com/posts/GNnHHmm8EzePmKzPk/value-is-fragile)?
🟡 ***ritsuko*** — ah, yes, the good old days when we believed this was the single obstacle to alignment.
🔴 ***asuka*** *barges into the room and exclaims* — hey, check this out! i found this [fancy new theory](https://www.lesswrong.com/tag/shard-theory) on lesswrong about how "shards of value" emerge in neural networks!
🔴 ***asuka*** *then walks away while muttering something about eiffel towers in rome and waluigi hyperstition…*
🟡 ***ritsuko*** indeed. these days, all these excited kids running around didn't learn about AI safety by thinking really hard about what agentic AIs would do — they got here by being spooked by large language models, and as a result they're thinking in all kinds of strange directions, like what it means for a language model to be aligned or how to locate natural abstractions for human values in neural networks.
🟢 ***shinji*** — of course that's what we're looking at! look around you, turns out that the shape of intelligence is RLHF'd language models, not agentic consequentialists! why are you still interested in those old ideas?
🟡 ***ritsuko*** — the problem, shinji, is that we *can't observe agentic AI being published before alignment is solved*. when someone figures out how to make AI consequentialistically pursue a coherent goal, whether by using current ML technology or by building a new kind of thing, we die shortly after they publish it.
🟣 ***misato*** — wait, isn't that anthropics? i'd rather stay away from that type of thinking, it seems too galaxybrained to reason about…
🟡 ***ritsuko*** — you can't really do that either — the ["back to square one"](https://www.lesswrong.com/posts/RnrpkgSY8zW5ArqPf/sia-greater-than-ssa-part-1-learning-from-the-fact-that-you) interpretation of anthropics, where you don't update at all, *is still an interpretation of anthropics*. it's kind of like being the kind of person who, when observing having survived quantum russian roulette 20 times in a row, assumes that the gun is broken rather than saying "i guess i might have low quantum amplitude now" and [fails to realize that the gun can still kill them](anthropics-example.html) — which is bad when all of our hopes and dreams rests on those assumptions. the only vaguely anthropics-ignoring perspective one can take about this is to ignore empirical evidence and stick to inside view, gears-level prediction of how convergent agentic AI tech is.
🟣 ***misato*** — …is it?
🟡 ***ritsuko*** — of course it is! on inside view, ***all the usual MIRI arguments hold just fine***. it just so happens that if you keep running a world forwards, and select only for worlds that we haven't died in, then you'll start observing stranger and stranger non-consequentialist AI. you'll start observing the kind of tech we get when just dumbly scale up bruteforce-ish methods *like machine learning* and you observe somehow nobody publishing insights as to how to make those systems agentic or consequentialistic.
🟢 ***shinji*** — that's kind of frightening!
🟡 ***ritsuko*** — well, it's where we are. we already thought we were small in space, now we also know that we're also small in probabilityspace. the important part is that it *doesn't particularly change what we should do* — we should still try to save the world, in the most straightforward fashion possible.
🟣 ***misato*** — so all the excited kids running around saying we have to figure out how to align language models or whatever…
🟡 ***ritsuko*** — they're chasing a chimera. impressive LLMs are not what we observe because they're what powerful AI looks like — they're what we observe because they're what powerful AI ***doesn't*** look like. they're there because that's as impressive as you can get short of something that kills everyone.
🟣 ***misato*** — i'm not sure most timelines are dead yet, though.
🟡 ***ritsuko*** — we don't know if "most" timelines are alive or dead from agentic AI, but we know that however many are dead, we couldn't have known about them. if [every AI winter was actually a bunch of timelines dying](https://twitter.com/carad0/status/1666092081889300481), we wouldn't know.
🟣 ***misato*** — you know, this doesn't necessarily seem so bad. considering that confused alignment people is what's caused the appearance of the three organizations trying to kill everyone as fast as possible, maybe it's better that alignment research seems distracted with things that aren't as relevant, rather than figuring out agentic AI.
🟡 ***ritsuko*** — you can say that alright! there's already enough capability hazards being carelessly published everywhere as it is, including on lesswrong. if people were looking in the direction of the kind of consequentialist AI that actually determines the future, this could cause a lot of damage. good thing there's a few very careful people here and there, studying the *right* thing, but being very careful by not publishing any insights. but this is indeed the kind of AI we need to figure out if we are to [save the world](outlook-ai-risk-mitigation.html).
🟢 ***shinji*** — whatever kind of anthropic shenanigans are at play here, they sure seem to be saving our skin! maybe we'll be fine because of quantum immortality or something?
🟣 ***misato*** — that's not how things work shinji. quantum immortality [explains how you got here, but doesn't help you save the future](https://www.lesswrong.com/posts/EKu66pFKDHFYPaZ6q/the-hero-with-a-thousand-chances).
🟢 ***shinji*** *sighs, with a defeated look on his face* — …so we're back to the good old MIRI alignment, we have to perfectly specify human values as a utility function *and* figure out how to align AI to it? this seems impossible!
🟡 ***ritsuko*** — well, that's where things get interesting! now that we're talking about coherent agents whose actions we can reason about, agents whose [instrumentally convergent goals such as goal-content integrity would be beneficial if they were aligned](https://en.wikipedia.org/wiki/Instrumental_convergence), agents who won't [mysteriously turn bad eventually](https://www.lesswrong.com/posts/GNhMPAWcfBCASy8e6/a-central-ai-alignment-problem-capabilities-generalization) because they're not yet coherent agents, we can actually *get to work putting something together*.
🟣 ***misato*** — …and that's what you've been doing?
🟡 ***ritsuko*** — well, that's kind of what [agent foundations had been about all along](https://twitter.com/ESYudkowsky/status/1626609128859922434), and what got rediscovered elsewhere as ["formal-goal alignment"](formal-alignment.html): designing an aligned coherent goal and figuring out how to make an AI that is aligned to maximizing it.
#### 2. embedded agency & untractability
🟢 ***shinji*** — so what's your idea? i sure could use some hope right now, though i have no idea what an aligned utility function would even *look like*. i'm not even sure what kind of *type signature* it would have!
🟡 ***ritsuko*** *smirks* — so, the first important thing to realize is that the challenge of designing an AI that emits output which save the world, can be formulated like this: design an AI trying to solve a mathematical problem, and make the mathematical problem be analogous enough to "what kind of output would save the world" that the AI, by solving it, happens to also save our world.
🟢 ***shinji*** — but what does that actually *look like*?
🟣 ***misato*** — maybe it looks like "what output should you emit, which would cause your predicted sequence of [stimuli](https://artint.info/2e/html/ArtInt2e.Ch2.S2.html) to look like a nice world?"
🟡 ***ritsuko*** — what do you think actually happens if an AI were to succeed at this?
🟣 ***misato*** — oh, i guess it would hack its stimuli input, huh. is there even a way around this problem?
🟡 ***ritsuko*** — what you're facing is a facet of the problem of [*embedded agency*](https://www.lesswrong.com/s/Rm6oQRJJmhGCcLvxh/p/i3BTagvt3HbPMx6PN). you must make an AI which thinks about the world which contains it, not just about a system that it feels like it is interacting with.
🟡 ***ritsuko*** — the answer — as in [PreDCA](predca.html) — is to model the world from the top-down, and ask: "look into this giant universe. you're in there somewhere. which action should the you-in-there-somewhere take, for this world to have the most expected utility?"
🟢 ***shinji*** — expected utility? by what utility function?
🟡 ***ritsuko*** — we're coming to it, shinji. there are three components to this: the **formal-goal-maximizing AI**, the **formal-goal**, and the **glue in-between**. [embedded agency](https://www.lesswrong.com/s/Rm6oQRJJmhGCcLvxh/p/i3BTagvt3HbPMx6PN) and [decision theory](https://arbital.com/p/logical_dt/) are parts of this glue, and they're core to how we think about the whole problem.
🟣 ***misato*** — and this top-down view works? how the hell would it compute *the whole universe*? isn't that uncomputable?
🟡 ***ritsuko*** — how the hell do you expect AI would have done expected utility maximization *at all*? by making [*reasonable guesses*](cant-simulate-the-universe.html). i can't compute the whole universe from the big-bang up to you right now, but if you give me a bunch of math which i'd understand to say "in worlds being computed forwards starting at some simple initial state and eventually leading to this room right now with shinji, misato, ritsuko in it, what is shinji more likely to be thinking about: his dad, or the pope's uncle?"
🟡 ***ritsuko*** — on the one hand, the question is immensely computationally expensive — it asks to compute the entire history of the universe up to this shinji! but on the other hand, it is talking about a world which *we inhabit*, and about which we have the ability to make *reasonable guesses*. if we build an AI that is smarter than us, you can bet it'll bet able to make guesses at least as well as this.
🟣 ***misato*** — i'm not convinced. after all, we relied on humans to make this guess! of course you can guess about shinji, you're a human like him. why would the AI be able to make those guesses, being the alien thing that it is?
🟡 ***ritsuko*** — i mean, one of its options is to *ask humans around*. it's not like it has to do everything by itself on its single computer, here — we're talking about the kind of AI that agentically saves the world, and has access to all kinds of computational resources, including humans if needed. i don't think it'll *actually* need to rely on human compute a lot, but the fact that it *can* serves as a kind of existence proof for its ability to produce reasonable solutions to these problems. not optimal solutions, but reasonable solutions — eventually, solutions that will be much better than any human or collection of humans could be able to come up with short of getting help from aligned superintelligence.
🟢 ***shinji*** — but what if the worlds that are actually described by such math are not in fact this world, but strange alien worlds that look nothing like ours?
🟡 ***ritsuko*** — yes, this is also part of the problem. but let's not keep moving the goalpost here. there are two problems: *make the formal problem point to the right thing (the right shinji in the right world)*, and *make an AI that is good at finding solutions to that problem*. both seem like we can solve them with some confidence; but we can't just keep switching back and forth between the two.
🟡 ***ritsuko*** — if you have to solve two problems A and B, then you have to solve A assuming B is solved, and then solve B assuming A is solved. then, you've got a pair of solutions which work with one another. here, we're solving the problem of whether an AI would be able to solve this problem, *assuming* the problem points to the right thing; later we'll talk about how to make the problem point to the right thing *assuming* we have an AI that can solve it.
🟢 ***shinji*** — are there any *actual implementation ideas* for how to build such a problem-solving AI? it sure sounds difficult to me!
🟣 ***misato***, *carefully peeking into the next room* — hold on. i'm not actually quite sure who's listening — it is known that capabilities people like to lurk around here.
🟤 ***kaji*** *can be seen standing against a wall, whistling, pretending not to hear anything.*
🟡 ***ritsuko*** — right. one thing i will reiterate, is that we should not observe a published solution to "how to get powerful problem-solving AI" before the world is saved. this is in the class of problems which we die shortly after a solution to it is found and published, so our lack of observing such a solution is not much evidence for its difficulty.
#### 3. one-shot AI
🟡 ***ritsuko*** — anyways, to come back to embedded agency.
🟣 ***misato*** — ah, i had a question. the AI returns a first action which it believes would overall steer the world in a direction that maximizes its expected utility. and then what? how does it get its observation, update its model, and take the next action?
🟡 ***ritsuko*** — well, there are a variety of clever schemes to do this, but an easy one is to just *not*.
🟣 ***misato*** — what?
🟡 ***ritsuko*** — to just *not do anything after the first action*. i think the simplest thing to build is what i call a ["one-shot AI"](delegated-embedded-agency-decision-theory.html), which halts after returning an action. and then we just run the action.
🟢 ***shinji*** — "run the action?"
🟡 ***ritsuko*** — sure. we can decide in advance that the action will be a linux command to be executed, for example. the scheme does not really matter, so long as the AI gets an output channel which has pretty easy bits of steering the world.
🟣 ***misato*** — hold on, hold on. a single action? what do you intend for the AI to do, output a really good pivotal act and then hope things get better?
🟡 ***ritsuko*** — have a little more imagination! our AI — let's call it AI₀ — will almost certainly return a single action that *builds and then launches another, better AI*, which we'll call AI₁. a powerful AI can absolutely do this, especially if it has the ability to read its own source-code for inspiration, but probably even without that.
🟡 ***ritsuko*** — …and because it's solving the problem "what action would maximize utility when inserted into this world", it will understand that AI₁ needs to have embedded agency and the various other aspects that are instrumental to it — [goal-content integrity](https://en.wikipedia.org/wiki/Instrumental_convergence#Goal-content_integrity), [robustly delegating](https://www.lesswrong.com/s/Rm6oQRJJmhGCcLvxh/p/i3BTagvt3HbPMx6PN#4__Robust_delegation) RSI, and so on.
🟢 ***shinji*** — "RSI"? what's that?
🟣 ***misato*** *sighs* — you know, it keeps surprising me how many youths don't know about the acronym RSI, which stands for Recursive Self-Improvement. it's pretty indicative of how little they're thinking about it.
🟢 ***shinji*** — i mean, of course! recursive self-improvement is an obsolete old MIRI idea that doesn't apply to the AIs we have today.
🟣 ***misato*** — right, kids like you got into alignment by being spooked by chatbots. (what [silly things](https://scottaaronson.blog/?p=6821) do they even teach you [in class](https://www.agisafetyfundamentals.com/ai-alignment-curriculum) these days?)
🟣 ***misato*** — you have to realize that the generation before you, the generation of ritsuko and i, didn't have the empirical evidence that AI was gonna be impressive. we started on something like [the empty string](https://twitter.com/esyudkowsky/status/1525285902628446208), or at least [coherent](https://www.readthesequences.com/) [arguments](https://publicism.info/philosophy/superintelligence/index.html) where we had to actually build a gears-level inside-view understanding of what AI would be like, and what it would be capable of.
🟣 ***misato*** — to me, one of the core arguments that sold me on the importance of AI and alignment was recursive self-improvement — the idea that *AI being better than humans at designing AI* would be a very special, very critical point in time, downstream of which AI would be able to beat humans at everything.
🟢 ***shinji*** — but this turned out irrelevant, because AI is getting better than humans *without* RSI–
🟡 ***ritsuko*** — again, false. we can **only** observe AI getting better than humans at intellectual tasks **without** RSI, because when RSI is discovered and published, we die very shortly thereafter. you have a sort of consistent survivorship bias, where you keep thinking of a whole class of things as *irrelevant* because they don't seem impactful, when in reality they're *the most* impactful; they're *so* impactful that when they happen you die and are unable to observe them.
#### 4. action scoring
🟣 ***misato*** — so, i think i have a vague idea of what you're saying, now. top-down view of the universe, which is untractable but [that's fine](cant-simulate-the-universe.html) apparently, thanks to some mysterious capabilities; [one-shot AI](delegated-embedded-agency-decision-theory.html) to get around various embedded agency difficulties. what's the actual utility function to align to, now? i'm really curious. i imagine a utility function assigns a value between 0 and 1 to any, uh, entire world? world-history? multiverse?
🟡 ***ritsuko*** — it assigns a value between 0 and 1 to any *distribution of worlds*, which is general enough to cover all three of those cases. but let's not get there yet; remember how the thing we're doing is untractable, and we're relying on an AI that can make guesses about it anyways? we're gonna rely on that fact a whole lot more.
🟣 ***misato*** — oh boy.
🟡 ***ritsuko*** — so, first: we're not passing a *utility function*. we're passing a *math expression* describing an *"action-scoring function"* — that is to say, a function attributing scores to *actions* rather than to *distributions over worlds*. we'll make the program deterministic and make it ignore all input, such that the AI has no ability to steer its result — [its true result is fully predetermined, and the AI has no ability to hijack that true result](noninterf-superint.html).
🟣 ***misato*** — wait, "hijack it"? aren't we assuming an inner-aligned AI, here?
🟡 ***ritsuko*** — i don't like this term, "inner-aligned"; [just like "AGI"](tabooing-agi.html), people use it to mean too many different and unclear things. we're assuming an AI which does its best to pick an answer to a math problem. that's it.
🟡 ***ritsuko*** — we don't make an AI which tries to not be harmful with regards to its side-channels, such as [hardware attacks](https://en.wikipedia.org/wiki/Rowhammer) — except for its output, it needs to be strongly boxed, such that it can't destroy our world by manipulating software or hardware vulnerabilities. similarly, we don't make an AI which tries to output a solution we *like*, it tries to output a solution which *the math would score high*. narrowing what we want the AI to do greatly helps us build the right thing, but it does add constraints to our work.
🟡 ***ritsuko*** *starts scribbling on a piece of paper on her desk* — let's write down some actual math here. let's call Ω the set of world-states, ΔΩ distributions over world-states, and A be the set of actions.
🟢 ***shinji*** — what are the types of all of those?
🟡 ***ritsuko*** — let's not worry about [that](qaci-math.html), for now. all we need to assume for the moment is that those sets are [countable](https://en.wikipedia.org/wiki/Countable_set). we could define both Ω≔𝔹\* and A≔𝔹\* — define them both as the set of finite bitstrings — and this would functionally capture all we need. as for distributions over world-states ΔΩ, we'll define ΔX≔{f|f∈X→[0;1],∑x∈Xxf(x)≤1} for any countable set X, and we'll call "mass" the number which a distribution associates to any element.
🟣 ***misato*** — woah, woah, hold on, i haven't looked at math in a while. what do all those squiggles mean?
🟡 ***ritsuko*** — ΔX is defined as the set of functions f, which take an X and return a number between 0 and 1, such that if you take the f of all x's in X and add those up, you get a number not greater than 1. note that i use a notation of sums ∑ where the variables being iterated over are above the ∑ and the constraints that must hold are below it — so this sum adds up all of the f(x) for each x such that x∈X.
🟣 ***misato*** — um, sure. i mean, i'm not quite sure what this *represents* yet, but i guess i get it.
🟡 ***ritsuko*** — the set ΔX of distributions over X is basically like saying "for any finite amounts of mass less than 1, what are some ways to distribute that mass among some or all of the X's?" each of those ways is a distribution; each of those ways is an f in ΔX.
🟡 ***ritsuko*** — anyways. the AI will take as input an untractable math expression of type A→[0;1], and return a single A. note that we're in math here, so "is of type" and "is in set" are really the same thing; we'll use ∈ to denote both set membership and type membership, because they're the same concept. for example, A→[0;1] is the set of all functions taking as input an A and returning a [0;1] — returning a real number between 0 and 1.
🟢 ***shinji*** — hold on, a *real* number?
🟡 ***ritsuko*** — well, a real number, but we're passing to the AI a discrete piece of math which will only ever describe countable sets, so we'll only ever describe countably many of those real numbers. infinitely many, but countably infinitely many.
🟣 ***misato*** — so the AI has type (A→[0;1])→A, and we pass it an action-scoring function of type A→[0;1] to get an action. checks out. where do utility functions come in?
🟡 ***ritsuko*** — they don't need to come in at all, actually! we'll be defining a piece of math which describes the world for the purpose of pointing at the humans who will decide on a scoring function, but the scoring function will only be over *actions the AI should take*.
🟡 ***ritsuko*** — the AI doesn't need to know that its math points to the world it's in; and in fact, conceptually, it isn't *told* this at all. on a *fundamental, conceptual* manner, it is not being told to care about the world it's in — if it could, it *would* take over our world and kill everyone in it to acquire as much compute as possible, and plausibly along the way [drop an anvil on its own head](https://www.lesswrong.com/tag/anvil-problem) because it doesn't have [embedded agency](https://www.lesswrong.com/s/Rm6oQRJJmhGCcLvxh/p/i3BTagvt3HbPMx6PN) with regards to the world around itself.
🟡 ***ritsuko*** — we will just very carefully box it such that its only meaningful output into our world, the only bits of steering it can predictably use, are those of the action it outputs. and we will also have very carefully designed it such that the only thing it ultimately cares about, is that that output have as high of an expected scoring as possible — it will care about this *intrinsically*, and *nothing else intrinsically*, such that doing that will be *more* important than hijacking our world through that output.
🟡 ***ritsuko*** — this meaning of "inner-alignment" is still hard to accomplish, but it is much better defined, much narrower, and thus hopefully much easier to accomplish than the "full" embedded-from-the-start alignments which [very slow, very careful corrigibility-based AI alignment would result in](https://www.glowfic.com/replies/1824457#reply-1824457).
#### 5. early math & realityfluid
🟣 ***misato*** — so what does that scoring function actually look like?
🟡 ***ritsuko*** — you know what, i hadn't started mathematizing my alignment idea yet; this might be a good occasion to get started on that!
🟡 ***ritsuko*** *wheels in a whiteboard* — so, what i expect is that the order in which we're gonna go over the math is going to be the *opposite order* to that of the [final math report on QACI](qaci-math.html). here, we'll explore things from the top-down, filling in details as we go — whereas the report will go from the bottom-up, fully defining constructs and then using them.
Prior∈ΔHypothesisLooksLikeThisWorld∈Hypothesis→[0;1]HowGood∈A→[0;1]hScore(action)≔∑Prior(h)⋅LooksLikeThisWorld(h)⋅HowGood(action,h)h∈Hypothesis
🟡 ***ritsuko*** — this is roughly what we'll be doing here. go over all hypotheses h the AI could have within some set of hypotheses, called Hypothesis; measure their Prior probability, the LooksLikeThisWorld that they correspond to our world, and how good the action are in them. this is the general shape of *expected scoring for actions*.
🟢 ***shinji*** — wait, the set of hypotheses is called Hypothesis, not Hypotheses? that's a bit confusing.
🟡 ***ritsuko*** — this is pretty standard in math, shinji. the reason to call the set of hypotheses Hypothesis is because, as explained before, sets are also types, and so LooksLikeThisWorld will be of type Hypothesis→[0;1] rather than Hypotheses→[0;1].
🟣 ***misato*** — what's in a Hypothesis, exactly?
🟡 ***ritsuko*** — the set of *all relevant beliefs about things*. or rather, the set of all relevant beliefs except for logical facts. [logical uncertainty](https://www.lesswrong.com/posts/SFLCB5BgjzruJv9sp/logical-and-indexical-uncertainty) will be a thing on the AI's side, not in the math — this math lives in the realm "platonic perfect true math", and the AI will have beliefs about what its various parts tend to result in as one kind of logical belief, just like it'll have beliefs about other logical facts.
🟣 ***misato*** — so, a mathematical object representing empirical beliefs?
🟡 ***ritsuko*** — i would rather put it as a pair of: *beliefs about what's real* ("realityfluid" beliefs); and *beliefs about where, in the set of real things, the AI is* (["indexical"](https://www.lesswrong.com/posts/SFLCB5BgjzruJv9sp/logical-and-indexical-uncertainty) beliefs). but this can be simplified by allocating realityfluid across *all* mathematical/computational worlds (this is equivalent to assuming [tegmark the level 4 multiverse](https://space.mit.edu/home/tegmark/crazy.html) is real, and can be done by assuming the cosmos to be [a "universal complete" program](universal-complete.html) running all computations) and then all beliefs are indexical. these two possibilities work out to pretty much the same math, anyways.
🟢 ***shinji*** — what the hell is "realityfluid"???
🟡 ***ritsuko*** — [i](limiting-real-universes.html)[t](persistent-data-structures-consciousness.html)['](universal-complete.html)[s](what-happens-when-you-die.html) [a](exact-minds-in-an-exact-world.html) [v](brittle-physics.html)[e](questions-cosmos-computations.html)[r](forking-bitrate-entropy-control.html)[y](deduplication-ethics.html) [l](udassa-time-steps.html)[o](hope-infinite-compute.html)[n](generalized-adding-reality-layers.html)[g](predictablizing-ethic-deduplication.html) [s](anthropic-reasoning-coordination.html)[t](solomonoff-deism.html)[o](hands-and-cities.html)[r](essential-inequality-vs-functional-inequivalence.html)[y](ethic-juice-anthropic-juice.html), [i](homomorphically-encrypted-computations.html)['](simulation-hypotheses.html)[m](logical-indexical-dignity.html) [a](spoiler-fire-upon-deep.html)[f](https://www.fanfiction.net/s/5389450/1/The-Finale-of-the-Ultimate-Meta-Mega-Crossover)[r](how-far-are-things-that-care.html)[a](approximate-decisions.html)[i](quantum-amplitude-deduplication.html)[d](https://carado.moe/up/52921a1c-bullshit.html).
🟣 ***misato*** — think of it as a measure of how some constant amount of "matteringness"/"realness" — typically 1 unit of it — is distributed across possibilities. even though it kinda mechanistically works like probability mass, it's "in the other direction": it represents what's *actually* real, rather than representing what we *believe*.
🟢 ***shinji*** — why would it sum to 1? what if there's [an infinite amount of stuff](hope-infinite-compute.html) out there?
🟣 ***misato*** — [your realityfluid still needs to sum up to some constant](https://twitter.com/ESYudkowsky/status/1644060293889249288). [if you allocate an infinite amount of matteringness, things break and don't make sense](https://www.lesswrong.com/posts/5iZTwGHv2tNfFmeDa/on-infinite-ethics).
🟡 ***ritsuko*** — indeed. this is why the most straightforward way to allocate realityfluid is to just imagine that the set of all that exists is a [universal program](universal-complete.html) whose computation is cut into time-steps each doing a constant amount of work, and then allocate some diminishing quantities of realityfluid to each time step.
🟣 ***misato*** — like saying that compute step number n≥1 has 12n realityfluid?
🟡 ***ritsuko*** — that would indeed normalize, but it diminishes *exponentially* fast. this makes world-states exponentially unlikely in the amount of compute they exist after; and there are philosophical reasons to say that exponential unlikelyness is what should count as non-existing.
🟢 ***shinji*** — what the hell are you talking about??
🟡 ***ritsuko*** *hands shinji [a paper called "Why Philosophers Should Care About Computational Complexity"](https://arxiv.org/abs/1108.1791)* — look, this is a whole other tangent, but basically, polynomial amounts of computation corresponds to "doing something", whereas exponential amounts of computation correspond to "magically obtaining something out of the ether", and this sort-of ramificates naturally across the rest of computational complexity applied to metaphysics and philosophy.
🟡 ***ritsuko*** — so instead, we can say that computation step number n≥1 has 1n2 realityfluid. this only diminishes quadratically, which is satisfactory.
🟡 ***ritsuko*** — oh, and for the same reason, the universal program needs to be quantum — for example, it needs to be a quantum equivalent of the classical universal program but for quantum computation, implemented on something like a [quantum turing machine](https://en.wikipedia.org/wiki/Quantum_Turing_machine)). otherwise, unless [BQP=BPP](https://en.wikipedia.org/wiki/BQP), quantum [multiverses](https://www.lesswrong.com/tag/many-worlds-interpretation) like ours might be exponentially expensive to compute, which would be [strange](solomonoff-deism.html).
🟢 ***shinji*** — why n2? why not n1.01 or n37?
🟡 ***ritsuko*** — those do indeed all normalize — but we pick 2 because at some point you just have to *pick something*, and 2 is a natural, [occam](https://www.lesswrong.com/posts/f4txACqDWithRi7hs/occam-s-razor)/[solomonoff](https://www.lesswrong.com/posts/EL4HNa92Z95FKL9R2/a-semitechnical-introductory-dialogue-on-solomonoff-1)-simple number which works. look, just–
🟢 ***shinji*** — and why are we assuming the universe is made of discrete computation anyways? isn't stuff made of real numbers?
🟡 ***ritsuko*** *sighs* — look, this is what the [church-turing-deutsch principle](https://en.wikipedia.org/wiki/Church%E2%80%93Turing%E2%80%93Deutsch_principle) is about. for any universe made up of real numbers, you can approximate it thusly:
* compute 1 step of it with every number truncated to its first 1 binary digit of precision
* compute 1 step of it with every number truncated to its first 2 binary digits of precision
for 1 time step with 1 bit of precision, then 2 time steps with 2 bits of precision, then 3 with 3, and so on. for any piece of branch-spacetime which is only finitely far away from the start of its universe, there exists a threshold at which it starts being computed in a way that is indistinguishable from the version with real numbers.
🟢 ***shinji*** — but they're only an approximation of us! they're not *the real thing!*
🟡 ***ritsuko*** *sighs* — you don't *know* that. you could be the approximation, and you would be unable to tell. and so, we can work without uncountable sets of real numbers, since they're unnecessary to explain observations, and thus an unnecessary assumption to hold about reality.
🟢 ***shinji***, *frustrated* — i *guess*. it still seems pretty contrived to me.
🟡 ***ritsuko*** — what else are you going to do? you're expressing things in *math*, which is made of *discrete expressions* and will only ever express *countable quantities of stuff*. **there is no uncountableness to grab at and use**.
🟣 ***misato*** — actually, can't we introduce [turing jumps/halting oracles](https://en.wikipedia.org/wiki/Turing_jump) into this universal program? [i heard that this lets us *actually compute* real numbers](https://en.wikipedia.org/wiki/Turing_jump).
🟡 ***ritsuko*** — there's kind-of-a-sense in which that's true. we could say that the universal program has access to a [first-degree halting oracle](https://en.wikipedia.org/wiki/Post%27s_theorem), or a 20th-degree; or maybe it runs for 1 step with a 1st degree halting oracle, then 2 steps with a 2nd degree halting oracle, then 3 with 3, and so on.
🟡 ***ritsuko*** — your program is now capable, at any time step, of computing an infinite amount of stuff. let's say one of those steps happens to run an entire universe of stuff, including a copy of us. how do you sub-allocate realityfluid? how much do we expect to be in there? you could allocate sub-compute-steps — with a 1st degree halting oracle executing at step n≥1, you allocate 1n2m2 realityfluid to each of the m≥1 infinite sub-steps in the call to the halting-oracle. you're just doing discrete realityfluid allocation again, except now your some of the realityfluid in your universe is allocated at people who have obtained results from a halting oracle.
🟡 ***ritsuko*** — this works, but what does it get you? assuming halting oracles is kind of a very strange thing to do, and regular computation with no halting oracles is *already* sufficient to explain this universe. so we don't. but sure, we could.
🟢 ***shinji*** *ruminates, unsure where to go from there.*
🟣 ***misato*** *interrupts* — hey, do we really need to cover this? let's say you found out that this whole view of things is wrong. could you fix your math then, to whatever is the correct thing?
🟡 ***ritsuko*** *waves around* — what?? what do you mean *if it's wrong*?? i'm not rejecting the premise that i might be wrong here, but like, my answer here depends a lot on *in what way i'm wrong* and *what is the better / more likely correct thing*. so, i don't know how to answer that question.
🟣 ***misato*** *snaps shinji back to attention* — that's fair enough, i guess. well, let's get back on track.
#### 6. precursor assistance
🟡 ***ritsuko*** — so, one insight i got for my alignment idea came from [PreDCA](predca.html), which stands for **Pre**cursor **D**etection, **C**lassification, and **A**ssistance. it consists of mathematizations for:
* the AI locating itself within possibilities
* locating the high-agenticness-thing which had lots of causation-bits onto itself — call it the "**Pre**cursor". this is supposed to find the human user who built/launched the AI. (**D**etection)
* bunch of criteria to ensure that the precursor is the intended human user and not something else (**C**lassification)
* extrapolating that precursor's utility function, and maximizing it (**A**ssistance)
🟣 ***misato*** — what the hell kind of math would accomplish that?
🟡 ***ritsuko*** — well, it's not entirely clear to me. some of it is explained, other parts seem like they're expected to just work naturally. in any case, this isn't so important — [the "Learning Theoretic Agenda" into which PreDCA fits](}https://www.lesswrong.com/posts/ZwshvqiqCvXPsZEct/the-learning-theoretic-agenda-status-2023) is not fundamentally similar to mine, and i do not expect it to be the kind of thing that saves us in time. as far as i predict, that agenda has purchased most of the [dignity points](https://www.lesswrong.com/posts/j9Q8bRmwCgXRYAgcJ/miri-announces-new-death-with-dignity-strategy) it will have cashed out when alignment is solved, when it inspired my own ideas.
🟢 ***shinji*** — and *your* agenda saves us in time?
🟡 ***ritsuko*** — a lot more likely so, yes! for one, i am not trying to build *an entire theory of intelligence and machine learning*, and i'm not trying to [develop](https://drive.google.com/drive/u/0/folders/1oabE7X87tQ22kYA6z9JEN8EZ3nLjnJFs) an *[elegant new form of bayesianism](https://www.lesswrong.com/tag/infra-bayesianism)* whose [model of the world](https://www.lesswrong.com/posts/gHgs2e2J5azvGFatb/infra-bayesian-physicalism-a-formal-theory-of-naturalized) has [concerning philosophical ramifications](https://www.lesswrong.com/posts/yykNvq257zBLDNmJo/infra-bayesianism-naturally-leads-to-the-monotonicity) which, while admittedly [possibly only temporary](https://www.lesswrong.com/posts/yykNvq257zBLDNmJo/infra-bayesianism-naturally-leads-to-the-monotonicity?commentId=sPTXpmeM6LPHk7LzA), make me concerned about the coherency of the whole edifice. what *i* am trying to do, is hack together the minimum viable [world-saving](outlook-ai-risk-mitigation.html) machine about which we'd have enough confidence that *launching it is better expected value than not launching it*.
🟡 ***ritsuko*** — anyways, the important thing is that that idea made me think "hey, what else could we do to even more make sure the selected precursor is the human use we want, and not something else like a nearby fly or the process of evolution?" and then i started to think of some clever schemes for locating the AI in a top-down view of the world, without having to decode physics ourselves, but rather by somehow pointing to the user "through" physics.
🟣 ***misato*** — what does that mean, exactly?
🟡 ***ritsuko*** — well, remember how PreDCA points to the user from-the-top-down? the way it tries to locate the user is by looking for *patterns, in the giant computation of the universe, which satisfy these criteria*. this fits in the general notion of [generalized computation interpretability](generalized-computation-interpretability.html), which is fundamentally needed to care about the world because you want to detect not just simulated moral patients, but [*arbitrarily complexly simulated* moral patients](homomorphically-encrypted-computations.html). so, you need this anyways, and it is what "looking inside the world to find stuff, no matter how it's encoded" looks like.
🟣 ***misato*** — and what sort of patterns are we looking for? what are the *types* here?
🟡 ***ritsuko*** — as far as i understand, PreDCA looks for *programs*, or *computations*, which take some input and return an policy. my own idea is to locate something less abstract, about which we can actually have information-theoretic guarantees: *bitstrings*.
🟣 ***misato*** — …just raw bitstrings?
🟡 ***ritsuko*** — that's right. the idea here is kinda like doing an incantation, except the incantation we're locating is a very large piece of data which is unlikely to be replicated outside of this world. imagine generating a very large (several gigabytes) file, and then asking the AI "look for things of information, in the set of all computations, which look like that pattern." we call "blobs" such bitstrings serving as \*anchors into to find our world and location-within-it in the set of possible world-states and locations-within-them.
#### 7. blob location
🟡 ***ritsuko*** — for example, let's say the universe is a [conway's game of life](https://en.wikipedia.org/wiki/Conway's_Game_of_Life). then, the AI could have a set of hypotheses as programs which take as input the entire state of the conway's game of life grid at any instant, and returning a bitstring which must be equal to the blob.
🟡 ***ritsuko*** — first, we define Ω≔{ω|ω∈𝒫(ℤ2),#ω∈ℕ} (uppercase omega, a set of lowercase omega) as the set of "world-states" — states of the grid, defined as the set of cell positions whose cell is alive.
🟢 ***shinji*** — what's 𝒫(ℤ2) and #ω?
🟡 ***ritsuko*** — ℤ2 is the set of pairs whose elements are both a member of ℤ, the set of relative integers. so Z2 is the set of pairs of relative integers — that is, grid coordinates. then, 𝒫(ℤ2) is the set of subsets of ℤ2. finally, #w is the size of set w — requiring that #w∈ℕ is akin to requiring that w is a finite set, rather than infinite. let's also define:
* 𝔹={⊤,⊥} as the set of booleans
* 𝔹\* as the set of finite bitstring
* 𝔹n is the set of bitstrings of length n
* |b| is the length of bitstring b
🟡 ***ritsuko*** — what do you think "locate blob b∈𝔹\* in world-state ω∈Ω" could look like, mathematically?
🟣 ***misato*** — let's see — i can use the set of bitstrings of same length as b, which is 𝔹|b|. let's build a set of {f|f∈Ω→𝔹|b|…
🟢 ***shinji*** — wait, Ω→𝔹|b| is the set of *functions* from Ω to 𝔹|n|. but we were talking about *programs* from Ω to 𝔹|b|. is there a difference?
🟡 ***ritsuko*** — this is a very good remark, shinji! indeed, we need to do a bit more work; for now we'll just posit that for any sets A,B, A→HB is the set of always-halting, always-succeeding programs taking as input an A and returning a B.
🟣 ***misato*** — let's see — what about {f|f∈Ω→H𝔹|b|,f(ω)=b}?
🟡 ***ritsuko*** — you're starting to get there — this is indeed the set of programs which return b when taking ω as input. however, it's merely a *set* — it's not very useful as is. what we'd really want is a *distribution* over such functions. not only would this give a *weight* to different functions, but summing over the entire distribution could also give us some measure of "how easy it is to find b in ω. remember the definition of distributions, ΔX?
🟢 ***shinji*** — oh, i remember! it's the set of functions in X→[0;1] which sum up to at most one over all of X.
🟡 ***ritsuko*** — indeed! so, we're gonna posit what i'll call *kolmogorov simplicity*, KX−∈ΔX∩X→(0;1), which is like [kolmogorov complexity](https://en.wikipedia.org/wiki/Kolmogorov_complexity) except that it's a *distribution*, never returns 0 nor 1 for a single element, and importantly it returns something like the *inverse* of complexity. it gives some amount of "mass" to every element in some (countable) set X.
🟣 ***misato*** — oh, i know then! the distribution, for each f∈Ω→H𝔹|b|, must return {KΩ→H𝔹\*−(f)iff(ω)=b0iff(ω)≠b
🟡 ***ritsuko*** — that's right! we can start to define Locn∈Ω×𝔹n→ΔΩ→H𝔹n as the function that takes as input a pair of world-state ω∈Ω and blob b∈𝔹n of length n, and returns a distribution over programs that "find" b in ω. plus, since functions f are weighed by their kolmogorov simplicity, for complex b's they're "encouraged" to find the bits of complexity of b *in* ω, rather than those bits of complexity being contained in f itself.
🟡 ***ritsuko*** — note also that this Locn distribution over Ω→H𝔹n returns, for any function f, either KΩ→H𝔹n− or 0, which entails that for any given ω,b, the sum of Locn(ω,b)(f) for all f's sums up to less than one — that sum represents in a sense "how hard it is to find b in ω" or "the probability that b is somewhere in ω".
f∀(ω,b)∈Ω×𝔹n:∑Locn(ω,b)(f)<1f∈Ω→H𝔹n
🟡 ***ritsuko*** — the notation here, Locn(ω,b)(f) is because Locn(ω,b) returns a distribution ΔΩ→H𝔹n, which is itself a function (Ω→H𝔹n)→[0;1] — so we apply Loc to ω,b, and then we sample the resulting distribution on f.
🟢 ***shinji*** — "the sum represents"? what do you mean by "represents"?
🟡 ***ritsuko*** — well, it's the concept which i'm trying to find a ["true name"](https://www.lesswrong.com/posts/FWvzwCDRgcjb9sigb/why-agent-foundations-an-overly-abstract-explanation) for, here. "how much is the blob b located in world-state ω? well, as much of the sum of the kolmogorov simplicity of every program that returns b when taking as input ω".
🟣 ***misato*** — and then what? i feel like my understanding of how this ties into anything is still pretty loose.
🟡 ***ritsuko*** — so, we're actually gonna get *two* things out of Loc: we're gonna get *how much ω contains b* (as the sum of Loc for all f's), but we're also gonna get *how to get another world-state that is like ω, except that b is replaced with something else*.
🟢 ***shinji*** — how are we gonna get *that*??
🟡 ***ritsuko*** — here's my idea: we're gonna make f(ω) return not just 𝔹\* but rather 𝔹n×𝔹\* — a pair of the blob of a "free bitstring" τ (tau) which it can use to store "everything in the world-state except b". and we'll also sample programs g∈𝔹n×𝔹\*→HΩ which "put the world-state back together" given the same free bitstring, and a *possibly different* counterfactual blob than b.
🟣 ***misato*** — so, for ω,b, Loc is defined as something like…
Locn(ω,b)∈Δ(Ω→H𝔹n×𝔹\*)×(𝔹n×𝔹\*→HΩ)Locn(ω,b)(f,g)≔{KΩ→H𝔹n×𝔹\*−(f)⋅K𝔹n×𝔹\*→HΩ−(g)if{letτ∈𝔹\*such thatf(ω)=(b,τ)ing(b,τ)=ω0otherwise
🟢 ***shinji*** *stares at the math for a while* — actually, shouldn't the if statement be more general? you don't just want g to work on b, you want g to work on *any other blob of the same length*.
🟡 ***ritsuko*** — that's correct shinji! let's call the original blob b the "factual blob", let's call other blobs of the same length we could insert in its stead "counterfactual blobs" and write them as b′ — we can establish that ′ (prime) will denote counterfactual things in general.
🟣 ***misato*** — so it's more like…
{letτ∈𝔹\*such thatf(ω)=(b,τ)in∀b′∈𝔹n:g(b′,τ)=…
🟣 ***misato*** — …g(b′,τ) should equal, exactly?
🟡 ***ritsuko*** — we don't know what it should equal, but we do know *something* about what it equals: f should work on that counterfactual and find the same counterfactual blob again.
{letτ∈𝔹\*such thatf(ω)=(b,τ)in∀b′∈𝔹n:f(g(b′,τ))=(b′,τ)
🟡 ***ritsuko*** — actually, let's make Locn be merely a distribution over functions that produce counterfactual world-states from counterfactual blobs 𝔹n→Ω — let's call those "counterfactual insertion functions" and denote them γ and their set Γn (gamma) — and we'll encapsulate τ away from the rest of the math:
f,g,τLocn(ω,b)(γ)≔∑KΩ→H𝔹n×𝔹\*−(f)⋅K𝔹n×𝔹\*→HΩ−(g)f∈Ω→H𝔹n×𝔹\*g∈𝔹n×𝔹\*→HΩf(ω)=(b,τ)∀b′∈𝔹n:f(g(b′,τ))=(b′,τ)γ(b′)=g(b′,τ)
🟢 ***shinji*** — isn't f(g(b′,τ))=(b′,τ) a bit circular?
🟡 ***ritsuko*** — well, yes and no. it leaves a lot of degrees of freedom to f and g, perhaps too much. let's say we had some function SimilarPasts∈Ω×Ω→[0;1] — let's not worry about how it works. then could weigh each "blob location" by how much counterfactual world-states are similar, when sampled over all counterfactual blobs.
🟣 ***misato*** — maybe we should also constrain the f,g programs for how long they take to run?
🟡 ***ritsuko*** — ah yes, good idea. let's say that for x∈X and f∈X→HY, R(f,x)∈ℕ\{0} is how long it takes to run program f on input x, in some amount of steps each doing a constant amount of work — such as steps of compute in a turing machine.
f,g,τb′Locn(ω,b)(γ)≔∑KΩ→H𝔹n×𝔹\*−(f)⋅K𝔹n×𝔹\*→HΩ−(g)⋅∑1#𝔹n⋅SimilarPasts(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,γ))f∈Ω→H𝔹n×𝔹\*b′∈𝔹ng∈𝔹n×𝔹\*→HΩf(ω)=(b,τ)∀b′∈𝔹n:f(γ(b′))=(b′,τ)γ(b′)=g(b′,τ)
🟡 ***ritsuko*** — (i've also replaced f(g(b′,τ)) with f(γ(b′)) since that's shorter and they're equal anyways)
🟣 ***misato*** — where does the first sum end, exactly?
🟡 ***ritsuko*** — it applies to the whole– oh, you know what, i can achieve the same effect by flattening the whole thing into a single sum. and renaming the b′ in ∀b′∈𝔹n to b′′ to avoid confusion.
f,g,τ,b′Locn(ω,b)(γ)≔∑KΩ→H𝔹n×𝔹\*−(f)⋅K𝔹n×𝔹\*→HΩ−(g)⋅1#𝔹n⋅SimilarPasts(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,τ))f∈Ω→H𝔹n×𝔹\*g∈𝔹n×𝔹\*→HΩb′∈𝔹nf(ω)=(b,τ)∀b′′∈𝔹n:f(γ(b′′))=(b′′,τ)γ(b′′)=g(b′′,τ)
🟢 ***shinji*** — are we still operating in conway's game of life here?
🟡 ***ritsuko*** — oh yeah, now might be a good time to start generalizing. we'll carry around not just world-states ω∈Ω, but *initial world-states* α∈Ω (alpha). those are gonna determine the start of *universes* — distributions of world-states being computed-over-time — and we'll use them when we're computing world-states forwards or comparing the age of world-states. for example SimilarPasts probably needs this, so we'll need to pass it to Locn which will now be of type Ω×Ω×𝔹n→ΔΓn:
f,g,τ,b′Locn(α,ω,b)(γ)≔∑KΩ→H𝔹n×𝔹\*−(f)⋅K𝔹n×𝔹\*→HΩ−(g)⋅1#𝔹n⋅SimilarPastsα(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,τ))f∈Ω→H𝔹n×𝔹\*g∈𝔹n×𝔹\*→HΩb′∈𝔹nf(ω)=(b,τ)∀b′′∈𝔹n:f(γ(b′′))=(b′′,τ)γ(b′′)=g(b′′,τ)
#### 8. constrained mass notation
🟢 ***shinji*** — i notice that you're multiplying together your "kolmogorov simplicities" and 1#𝔹n and now SimilarPasts divided by a sum of how long they take to run. what's going on here exactly?
🟡 ***ritsuko*** — well, each of those number is a "confidence amount" — scalars between 0 and 1 that say "how much does *this* iteration of the sum capture the thing we want", like probabilities. multiplication ⋅ is like the logical operator "and" ∧ except for confidence ratios, you know.
🟢 ***shinji*** — ah, i see. so these sums do something kinda like "expected value" in probability?
🟡 ***ritsuko*** — something kinda like that. actually, this notation is starting to get unwieldy. i'm noticing a bunch of this pattern: x∑SomeDistribution(x)⋅expressionx∈SomeSet
🟣 ***misato*** — so, if you want to use the standard probability theory notations, you need random variables which–
🟡 ***ritsuko*** — ugh, i *don't like* random variables, because the place at which they get substituted for the sampled value is ambiguous. here, i'll define my own notation:
v1,…,vpv1,…,vpM[V]≔∑X1(x1)⋅…⋅Xn(xn)⋅Vx1:X1x1∈domain(X1)⋮⋮xn:Xnxn∈domain(Xn)C1C1⋮⋮CmCm
🟡 ***ritsuko*** — 𝐌 will stand for "constrained mass", and it's basically [syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar) for sums, where x:X means "sum over x∈domain(X) (where domain returns the set of arguments over which a function is defined), and then multiply each iteration of the sum by X(x)". now, we just have to define uniform distributions over finite sets as…
🟢 ***shinji*** — UniformX(x)≔1#X for finite set X?
🟡 ***ritsuko*** — that's it! and now, Loc is much more easily written down:
f,g,τ,b′Locn(α,ω,b)(γ)≔𝐌[SimilarPastsα(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,τ))]f:KΩ→H𝔹n×𝔹\*−g:K𝔹n×𝔹\*→HΩ−b′:Uniform𝔹nf(ω)=(b,τ)∀b′′∈𝔹n:f(γ(b′′))=(b′′,τ)γ(b′′)=g(b′′,τ)
🟢 ***shinji*** — huh. you know, i'm pretty skeptical of you inventing your own probability notations, but this *is* much more readable, when you know what you're looking at.
🟣 ***misato*** — so, are we done here? is this blob location?
🟡 ***ritsuko*** — well, i expect that some thing are gonna come up later that are gonna make us want to change this definition. but right now, the only improvement i can think of is to replace f:KΩ→H𝔹n×𝔹\*− and g:K𝔹n×𝔹\*→HΩ− with (f,g):K(Ω→H𝔹n×𝔹\*)×(𝔹n×𝔹\*→HΩ)−.
🟣 ***misato*** — huh, what's the difference?
🟡 ***ritsuko*** — well, now we're sampling f,g from kolmogorov simplicity *at the same time*, which means that if there is some large piece of information that they both use, they won't be penalized for using it twice but only once — a tuple containing two elements which have a lot of information in common only has that information counter once by K−.
🟣 ***misato*** — and we want that?
🟡 ***ritsuko*** — yes! there are some cases where we'd want two mathematical objects to have a lot of information in common, and other places where we'd want them to not need to be dissimilar. here, it is clearly the former: we want the program that "deconstructs" the world-state into blob and everything-else, and the function that "reconstructs" a new world-state from a counterfactual blob and the same everything-else, to be able to share information as to how they do that.
#### 9. what now?
🟢 ***shinji*** — so we've put together a true name for "piece of data in the universe which can be replaced with counterfactuals". that's pretty nifty, i guess, but what do we do with it?
🟡 ***ritsuko*** — now, this is where the core of my idea comes in: in the physical world, we're gonna create a random unique enough blob on someone's computer. then we're going to, still in the physical world, read its contents right after generating it. if it looks like a counterfactual (i.e. if it doesn't look like randomness) we'll create another blob of data, which can be recognized by Loc as an answer.
🟢 ***shinji*** — what does that entail, exactly?
🟡 ***ritsuko*** — we'll have created a piece of *real, physical world*, which lets use use Loc to get the *true name, in pure math*, of "what answer would that human person have produced to this counterfactual question?"
🟣 ***misato*** — hold on — we already have this. the AI can already have an interface where it asks a human user something, and waits for our answer. and the problem with that is that, obviously, the AI hijacks us or its interface to get whatever answer makes its job easiest.
🟡 ***ritsuko*** — aha, but this is different! we can point at a counterfactual question-and-answer chunk-of-time (call it "question-answer counterfactual interval", or "QACI") which is *before* the AI's launch, in time. we can mathematically *define* it as being in the past of the AI, by identifying the AI with some other blob which we'll also locate using Loc, and demand that the blob identifying the AI be *causally after* the user's answer.
🟣 ***misato*** — huh.
🟡 ***ritsuko*** — that's another idea i got from PreDCA — making the AI pursue the values of [*a static version of its user in its past*](outer-alignment-past-user.html), rather than its user-over-time.
🟢 ***shinji*** — but we don't want the AI to lock-in our values, we want the AI to satisfy our values-as-they-evolve-over-time, don't we?
🟣 ***misato*** — well, shinji, there's multiple ways to phrase your mistake, here. one is that, actually, [you do](surprise-you-want.html) — but if you're someone *reasonable*, then the values you endorse are some metaethical system which is able to reflect and learn about what's good, and to let people and philosophy determine what can be pursued.
🟣 ***misato*** — but you *do* have values you want to lock in. your meta-values, your metaethics, you don't want *those* to be able to change arbitrarily. for example, you probly don't want to be able to become someone who wants everyone to maximally suffer. those endorsed, top-level, metaethics meta-values, are something you *do* want to lock in.
🟡 ***ritsuko*** — put it another way: if you're reasonable, then if the AI asks you what you want inside the question-answer counterfactual interval, you won't answer "i want everyone to be forced to watch the most popular TV show in 2023". you'll answer something more like "i want everyone to be able to reflect on their own values and choose what values and choices they endorse, and how, and that the field of philosophy can continue in these ways in order to figure out how to resolve conflicts", or something like that.
🟣 ***misato*** — wait, if the AI is asking the user counterfactual questions, won't it ask the user whatever counterfactual question brainhacks the user into responding whatever answer makes its job easiest? it can just hijack the QACI.
🟡 ***ritsuko*** — aha, but we don't have to have *the AI* formulate answers! we could do something like: make the initial question some static question like "please produce an action that saves the world", and then the user thinks about it for a bit, returns an answer, and that answer is fed back into another QACI to the user. this loops until one of the user responds with an answer which starts with a special string like "okay, i'm done for sure:", followed by a bunch of text which the AI will interpret as a piece of math describing a scoring over actions, and it'll try to output a utility function which maximizes *that*.
🟢 ***shinji*** — so it's kinda like [coherent extrapolated volition](https://www.lesswrong.com/tag/coherent-extrapolated-volition) but for actions?
🟡 ***ritsuko*** — sure, i think of it as [*an implementation of CEV*](cev-coherent-enough.html). it allows its user to run a long-reflection process. actually, that long-reflection process even has the ability to use a mathematical oracle.
🟣 ***misato*** — how does *that* work?
#### 10. blob signing & closeness in time
🟡 ***ritsuko*** — so, let's define QACI as a function, and this'll clarify what's going on. q∈𝔹\* will be our initial random factual question blob. QACI∈Ω×Γ|q|×𝔹|q|→Δ𝔹|q| takes as parameter a blob location for the question — which, remember, comes in the form of a function you can use to produce counterfactual world-states with counterfactual blobs! — and a counterfactual question blob q′, and returns a distribution of possible answers r. it's defined as:
ωr,γrQACI(α,γq,q′)(r)≔𝐌[1]ωr:Ωα→(γq(q′))γr:Loc|q|(α,ωr,r)
🟡 ***ritsuko*** — we're, for now just positing, that there is a function Ωα→∈Ω→ΔΩ (remember that α defines a hypothesis for the initial state, and mechanics, of our universe) which, given a world-state, returns a distribution of world-states that are in its future. so this piece of math samples possible future world-states of the counterfactual world-state where q was replaced with q′, and possible locations of possible answers in those world-states.
🟣 ***misato*** — 𝐌[1]? what does *that* mean?
🟡 ***ritsuko*** — here, the fact that Locn(α,ω,b) *doesn't necessarily sum to 1* — we say that it *doesn't normalize* — means that QACI(α,γq,q′)(r) summed up over all r∈𝔹|q| can be less than 1. in fact, this sum will indicate "how hard is it to find the answer r in futures of counterfactual world-states γq(q′)?" — and uses that as the distribution of answers.
🟣 ***misato*** — hmmm. wait, this just finds whichever-answers-are-the-easiest-to-find. what guarantees that r looks like *an answer at all*?
🟡 ***ritsuko*** — this is a good point. maybe we should define something like Sign∈𝔹\*→𝔹|q| which, to any input "payload" of a certain length, associates a blob which is actually highly complex, because Sign embeds a lot of bits of complexity. for example, maybe Sign(π) (where π is the "payload") concatenates π together with a long [cryptographic hash](https://en.wikipedia.org/wiki/Cryptographic_hash_function) of π and of some piece of information highly entangled with our world-state.
ωr,γrQACI(α,γq,q′)(πr)≔𝐌[1]ωr:Ωα→(γq(q′))γr:Loc|q|(α,ωr,Sign(πr))
🟢 ***shinji*** — we're not signing the counterfactual question q′, only the answer payload πr?
🟡 ***ritsuko*** — that's right. signatures matter for blobs we're *finding*; once we've found them, we don't need to sign counterfactuals to insert in their stead.
🟣 ***misato*** — so, it seems to me like how Ω→ works here, is pretty critical. for example, if it contains a bunch of mass at world-states where some AI is launched, whether ours or another, then that AI will try to fill its future lightcone with answers that would match various Sign(πr)'s — so that *our* AI would find those answers instead of ours — and make those answers be something that maximize *their* utility function rather than ours.
🟡 ***ritsuko*** — this is true! indeed, how we sample for Ω→ is pretty critical. how about this: first, we'll pass the distribution into Loc:
γrQACI(α,γq,q′)(πr)≔𝐌[1]γr:Loc|q|(α,Ωα→(γq(q′)),Sign(πr))
🟡 ***ritsuko*** — …and inside Locn, which is now of type Locn∈Ω×ΔΩ×𝔹n→ΔΓn, for any f,g we'll only sample world-states ω which have the *highest* mass in that distribution:
f,g,ω,τ,b′Locn(α,δ,b)(γ)≔𝐌[SimilarPastsα(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,τ))](f,g):K(Ω→H𝔹n×𝔹\*)×(𝔹n×𝔹\*→HΩ)−ω:λω:maxXΔ(λω:Ω.{δ(ω)iff(ω)=(b,τ)0otherwise).δ(ω)b′:Uniform𝔹nf(ω)=(b,τ)∀b′′∈𝔹n:γ(b′′)=g(b′′,τ)f(γ(b′′))=(b′′,τ)
🟡 ***ritsuko*** — the intent here is that for any way-to-find-the-blob f,g, we only sample the closest matching world-states in time — which *does* rely on Ω→ having higher mass for world-states that are closer in time. and hopefully, the result is that we pick enough instances of the signed answer blobs located shortly in time after the question blobs, that they're mostly dominated by *the human user answering them*, rather than AIs appearing later.
🟣 ***misato*** — can you disentangle the line where you sample ω?
🟡 ***ritsuko*** — sure! so, we write an anonymous function λω:X.δ(ω) — a distribution is a function, after all! — taking a parameter ω from the set X, and returning δ(ω). so this is going to be a distribution that is just like δ, except it's only defined for a subset of Ω — those in X.
🟡 ***ritsuko*** — in this case, X is defined as such: first, take the set of elements ω∈Ω for which f(ω)=(b,τ). then, apply the distribution δ to all of them, and only keep elements for which they have the most δ (there can be multiple, if multiple elements have the same maximum mass!).
🟡 ***ritsuko*** — oh, and i guess f(ω)=(b,τ) is redundant now, i'll erase it. remember that this syntax means "sum over the body for all values of f,g,ω,τ,b′ for which these constraints hold…", which means we can totally have the value of τ be bound inside the definition of ω like this — it'll just have exactly one value for any pair of f and α.
#### 11. QACI graph
🟢 ***shinji*** — why is QACI returning a distribution over answers, rather than picking the single element with the most mass in the distribution?
🟡 ***ritsuko*** — that's a good question! in theory, it could be that, but we do want the user to be able to go to the next possible counterfactual answer if the first one isn't satisfactory, and the one after that if *that's* still not helpful, and so on. for example: in the piece of math which will interpret the user's final result as a math expression, we want to ignore answers which don't parse or evaluate as proper math of the intended type.
🟢 ***shinji*** — so the AI is asking the counterfactual past-user-in-time to come up with a good action-scoring function in… however long a question-answer counterfactual interval is.
🟡 ***ritsuko*** — let's say about a week.
🟢 ***shinji*** — and this helps… how, again?
🟡 ***ritsuko*** — well. first, let's posit EvalMathX∈𝔹\*→{{x}|x∈X}∪{∅}, which tries to parse and evaluate a bitstring representing a piece of math (in some pre-established formal language) and returns either:
* what it evaluates to if it is a member of X
* an empty set if it isn't a member of X or fails to parse or evaluate
🟡 ***ritsuko*** — we then define EvalMathXΔ∈ΔΠ→X as a function that returns the highest-mass element of the distribution for which EvalMathX returns a value rather than the empty set. we'll also assume for convenience q\*′∈\*→𝔹|q|, a convenience function which converts any mathematical object into a counterfactual blob 𝔹|q|. this isn't really allowed, but it's just for the sake of example here.
🟣 ***misato*** — okay…
🟡 ***ritsuko*** — so, let's say the first call is QACI(α,γq,q\*′("please produce a good action-scoring")). the user can return *any expression*, as their action-scoring function — they can return λa:A.SomeUtilityMeasure(a) (a function taking an action a and returning some utility measure over it), but they can also return EvalMathUΔ(QACI(α,γq,q\*′("here are some ideas: …"))) where U≔A→[0;1] is the set of action-scoring functions. they get to *call themselves recursively*, and make progress in a sort of time-loop where they pass each other notes.
🟣 ***misato*** — right, this is the long-reflection process you mentioned. and about the part where they get a mathematical oracle?
🟡 ***ritsuko*** — so, the user can return things like:
EvalMathUΔ(QACI(α,γq,q\*′(SomeUncomputableQuery())))
EvalMathUΔ(QACI(α,γq,q\*′(Halts(SomeProgram,SomeInput)))).
🟣 ***misato*** — huh. that's nifty.
🟢 ***shinji*** — what if some weird memetic selection effects happen, or what if in one of the QACI intervals, the user randomly gets hit by a truck and then the whole scheme fails?
🟡 ***ritsuko*** — so, the user can set up giant giant [acyclic graphs](https://en.wikipedia.org/wiki/Directed_Acyclic_Graph) of calls to themselves, providing a lot of redundancy. that way, if any single node fails to return a coherent output, the next nodes can notice this and keep working with their peer's output.
🟡 ***ritsuko*** — a small graph of QACI can be accomplished with something like
EvalMathUΔ(QACI(α,γq,q\*′(EvalMathUΔ(QACI(α,γq,q\*′("what about this…"))),EvalMathUΔ(QACI(α,γq,q\*′("what about that…"))))))
🟡 ***ritsuko*** — and you can imagine how this could be extended to a larger structure such as:
#### 12. fictional agents
🟢 ***shinji*** — wait a minute; what if the QACI user goes crazy from realizing that they're *fictional, inside an AI's hypothesis*, rather than in the physical world-state? especially if they have access to a goddamn math oracle.
🟡 ***ritsuko*** — ah. uuh. well, don't panic shinji, but, **we are fictional. right now.**
🟢 ***shinji*** *starts flailing around.*
🟣 ***misato*** — what the hell are you talking about?
🟡 ***ritsuko*** — misato, come on. we're inside a crazy high-tech compound designed to build and maintain giant robots to fight alien creatures, *and* we're discussing the entirely unrelated topic of AI alignment. oh, and, uh, there's this:
🔵 ***rei*** *appears in front of them and waves at the camera.*
🟣 ***misato*** — …so, why are we talking about alignment, instead of, i don't know, trying to escape?
🟡 ***ritsuko*** — misato, this is *fiction*, you don't *escape*. instead, you reason about what agents are writing your fiction. based on prior, we should vaguely guess that they're like us, and that the conversation we're having is useful for them to write a fiction about. my guess is, we're a fiction written by someone who's trying to communicate ideas about AI alignment and, for some godforsaken reason i cannot imagine, decided that *we* should be the characters having this conversation.
🟡 ***ritsuko*** — but don't be mistaken: if we are indeed fictional, then the future of this world we're observing barely matters. our parent world likely holds a lot more realityfluid. so we shou–
🟢 ***shinji***, *shaking* — here comes this "realityfluid" [bullshit](https://carado.moe/up/52921a1c-bullshit.html) again!
🟡 ***ritsuko*** — anyways, the coherent thing for fictional characters to do [is to try to steer their parent world, because it's generally "realer"](approximate-decisions.html). and generally, this is achieved by cooperating with whatever their parent world seems to be doing, so we should probably just continue to discuss AI alignment.
🟡 ***ritsuko*** — and, in a similar manner, there are people who grok these facts sufficiently well that we would expect them to take the correct actions, even upon realizing that they are the fictional consideration of a superintelligence. given the explanation i just gave, i would claim that i could do it myself, for one.
🔵 ***rei*** *magically erases everyone's memory of this section of the dialogue, and then disappears, out of view from everyone.*
#### 13. top-level QACI call
🟢 ***shinji*** — so we have QACI(α,γq,q′), the function which can call itself recursively. what's the top-level, terminal call to it which yields the action-scoring function?
🟡 ***ritsuko*** — ah, i think it'd look like:
πrQACI0(α,γq)(u)≔𝐌[1]πr:QACI(α,γq,q0′)u∈EvalMathU(πr)
🟡 ***ritsuko*** — where q0′ is some initial counterfactual blob, such as the plaintext string "please return a good scoring function over actions" encoded in ASCII, and then padded with zeros to be of the size needed for a blob. QACI0 has type Γ|q|→ΔU — from a question location, it returns a distribution of action-scoring functions.
🟣 ***misato*** — so like, the counterfactual user inside the QACI call should be able to return math that calls more QACI, but where do *they* get the α and γq?
🟢 ***shinji*** — couldn't they return the whole math?
🟡 ***ritsuko*** — ah, that's not gonna work — the chance of erroneous blob locations might accumulate too much if each QACI does a new question location sampling; we want something more realiable. an easy solution is to EvalMath the text not into a U, but into a Ω×Γ|q|→U and to pass it α,γq so that the user can return a function which receives those and uses them to call QACI.
🟡 ***ritsuko*** — actually, while we're at it, we can pass a it whole lot more things it might need…
πr,fQACI0(α,γq)(u)≔𝐌[1]πr:QACI(α,γq,q0′)f∈EvalMath{q}×Ω×Γ|q|→U(πr)f(q,α,γq)=u
🟢 ***shinji*** — what's going on with f here?
🟡 ***ritsuko*** — oh, this is just a trick of how we implement distributions — when measuring the mass of any specific u, we try to EvalMath the answer payload into a function f, and we only count the location when u is equal to f(q,α,γq) with useful parameters passed to it.
🟣 ***misato*** — what's *around* QACI0? where do α and γq come from?
🟡 ***ritsuko*** — so… remember this?
hScore(a)≔𝐌[LooksLikeThisWorld(h)⋅HowGood(a,h)]h:Prior
🟡 ***ritsuko*** — this is where we start actually plugging in our various parts. we'll assume some distribution over initial world-states Ωα∈ΔΩ and sample question locations γq in futures of those initial world-states — which will serve, for now, as the LooksLikeThisWorld.
α,γqScore(a)≔𝐌[QACI0(α,γq)(a)]α:Ωαγq:Loc|q|(α,Ωα→(α),q)
🟡 ***ritsuko*** — the actual AI we use will be of a type like U→HA, and so we can just call AI(Score), and execute its action guess.
🟣 ***misato*** — and… that's it?
🟡 ***ritsuko*** — well, no. i mean, the whole fundamental structure is here, but there's still a bunch of work we should do if we want to increase the chances that this produces the outcomes we want.
#### 14. location prior
🟡 ***ritsuko*** — so, right now each call to Loc penalizes f,g for being being too kolmogorov-complex. we could take advantage of this by encouraging our two different blob locations — the question location and the answer location — to share bits of information, rather than coming up with their own, possibly different bits of information. this increases the chances that the question is located "in a similar way" to the answer.
🟣 ***misato*** — what does this mean, concretely?
🟡 ***ritsuko*** — well, for example, they could have the same bits of information for *how to find bits of memory on a computer's memory on earth, encoded in our physics*, and then the two different Loc's f and g functions would only differ in what computer, what memory range, and what time they find their blobs in.
🟡 ***ritsuko*** — for this, we'll define a set of "location priors" being sampled as part of the hypothesis that Score samples over — let's call it Ξ (xi). we might as well posit Ξ≔𝔹\*.
🟡 ***ritsuko*** — we'll also define KP,X−~:P→ΔX a kolmogorov simplicity measure which can use another piece of information, as, let's see…
KP,X−~(p)(x)≔KP×X−(p,x)
🟡 ***ritsuko*** — there we go, measuring the simplicity of the pair of the prior and the element favors information being shared between them.
🟣 ***misato*** — wait, this fails to normalize now, doesn't it? because not all of P×X is sampled, only pairs whose first element is p.
🟡 ***ritsuko*** — ah, you're right! we can simply normalize this distribution to solve that issue.
KP,X−~(p)≔NormalizeX(λx:X.KP×X−(p,x))
🟡 ***ritsuko*** — and in Score we'll simply add ξ:KΞ− and then pass ξ around to all blob locations:
α,ξ,γqScore(u)≔𝐌[QACI0(α,γq,ξ)(u)]α:Ωαξ:KΞ−γq:Loc|q|(α,Ωα→(α),q,ξ)
QACI0∈Ω×Γ|q|×Ξ→ΔU
πr,fQACI0(α,γq,ξ)(u)≔𝐌[1]πr:QACI(α,γq,q0′,ξ)f∈EvalMath{q}×Ω×Γ|q|×Ξ→U(πr)f(q,α,γq,ξ)=u
🟡 ***ritsuko*** — finally, we'll use it in Loc to sample f,g from:
Locn∈Ω×ΔΩ×𝔹n×Ξ→ΔΓn
f,g,ω,τ,b′Locn(α,δ,b,ξ)(γ)≔𝐌[SimilarPastsα(ω,g(b′,τ))R(g,(b′,τ))+R(f,g(b′,τ))](f,g):KΞ,(Ω→H𝔹n×𝔹\*)×(𝔹n×𝔹\*→HΩ)−~(ξ)ω:λω:maxXΔ(λω:Ω.{δ(ω)iff(ω)=(b,τ)0otherwise).δ(ω)b′:Uniform𝔹n∀b′′∈𝔹n:γ(b′′)=g(b′′,τ)f(γ(b′′))=(b′′,τ)
#### 15. adjusting scores
🟡 ***ritsuko*** — here's an issue: currently in Score, we're weighing hypotheses by how hard it is to find both the question and the answer.
🟡 ***ritsuko*** — do you think that's wrong?
🟣 ***misato*** — i think we should first ask for how hard it is to find questions, and then normalize the distribution of answers, so that harder-to-find answers don't penalize hypotheses. the reasoning behind this is that we want QACI graphs to be able to do a lot of complicated things, and that we hope question location is sufficient to select what we want already.
🟡 ***ritsuko*** — ah, that makes sense, yeah! thankfully, we can just normalize right around the call to QACI0, before applying it to u:
α,ξ,γqScore(u)≔𝐌[NormalizeU(QACI0(α,γq,ξ))(u)]α:Ωαξ:KΞ−γq:Loc|q|(α,Ωα→(α),q,ξ)
🟢 ***shinji*** — what happens if we don't get the blob locations we want, exactly?
🟡 ***ritsuko*** — well, it depends. there are two kinds of "blob mislocations": ["naive" and "adversarial" ones](blob-causality.html). naive mislocations are hopefully not a huge deal; considering that we're doing average scoring over all scoring functions weighed by mass, hopefully the "signal" from our aligned scoring functions beats out the "noise" from locations that select the wrong thing at a random place, like "[boltzmann](https://en.wikipedia.org/wiki/Boltzmann_brain) blobs".
🟡 ***ritsuko*** — adversarial blobs, however, are tougher. i expect that they mostly result from unfriendly alien superintelligences, as well as earth-borne AI, both unaligned ones and ones that might result from QACI. against those, i hope that inside QACI we come up with some [good decision theory](https://arbital.com/p/logical_dt/) that lets us not worry about that.
🟣 ***misato*** — actually, didn't someone recently publish some work on a [threat-resistant utility bargaining function](https://www.lesswrong.com/posts/vJ7ggyjuP4u2yHNcP/threat-resistant-bargaining-megapost-introducing-the-rose), called "Rose"?
🟡 ***ritsuko*** — oh, nice! well in that case, if Rose is of type ΔU→U, then we can simply wrap it around all of Score:
α,ξ,γqScore≔Rose(λu:U.𝐌[NormalizeU(QACI0(α,γq,ξ))(u)])α:Ωαξ:KΞ−γq:Loc|q|(α,Ωα→(α),q,ξ)
🟡 ***ritsuko*** — note that we're putting the whole thing inside an anonymous λ-function, and assigning to Score the result of applying Rose to that distribution.
#### 16. observations
🟢 ***shinji*** — you know, i feel like there ought to be some better ways to select hypotheses that look like our world.
🟡 ***ritsuko*** — hmmm. you know, i do feel like if we had some "observation" bitstring μ∈𝔹\* (mu) which strongly identifies our world, like a whole dump of wikipedia or something, that might help — something like γμ:Loc|μ|(α,Ωα→(α),μ,ξ). but how do we tie that into the existing set of variables serving as a sampling?
🟣 ***misato*** — we could look for the question q in futures of the observation world-state– how do we get that world-state again?
🟡 ***ritsuko*** — oh, if you've got γμ you an reconstitute the factual observation world-state with γμ(μ).
🟣 ***misato*** — in that case, we can just do:
α,ξ,γμ,γqScore≔Rose(λu:U.𝐌[NormalizeU(QACI0(α,γq,ξ))(u)])α:Ωαξ:KΞ−γμ:Loc|μ|(α,Ωα→(α),μ,ξ)γq:Loc|q|(α,Ωα→(γμ(μ)),q,ξ)
🟡 ***ritsuko*** — oh, neat! actually, couldn't we generate *two* blobs and sandwich the question blob between the two?
🟣 ***misato*** — let's see here, the second observation can be μ2…
α,ξ,γμ1,γμ2,γqScore≔Rose(λu:U.𝐌[NormalizeU(QACI0(α,γq,ξ))(u)])α:Ωαξ:KΞ−γμ1:Loc|μ1|(α,Ωα→(α),μ1,ξ)γμ2:Loc|μ2|(α,Ωα→(γμ1(μ1)),μ2,ξ)γq:Loc|q|(α,Ωα→(γμ1(μ1)),q,ξ)
🟣 ***misato*** — how do i sample the γq location from both the future of γμ1 *and* the past of γμ2?
🟡 ***ritsuko*** — well, i'm not sure we want to do that. remember that Loc tries to find the *very first* matching world-state for any f,g. instead, how about this:
α,ξ,γμ1,γμ2,γqScore≔Rose(λu:U.𝐌[NormalizeU(QACI0(α,γq,ξ))(u)])α:Ωαξ:KΞ−γμ1:Loc|μ1|(α,Ωα→(α),μ1,ξ)γμ2:Loc|μ2|(α,Ωα→(γμ1(μ1)),μ2,ξ)γq:Loc|q|(α,Ωα→(γμ2(μ2)),q,ξ)Ωα→(γq(q))(γμ2(μ2))>Ωα→(γμ2(μ2))(γq(q))
🟡 ***ritsuko*** — it's a bit hacky, but we can simply demand that "the μ2 world-state be in the future of the q world-state more than the q world-state is in the future of the μ2 world-state".
🟣 ***misato*** — huh. i guess that's… one way to do it.
🟢 ***shinji*** — could we encourage the blob location prior to use the bits of information from the observations? something like…
α,ξ,γμ1,γμ2,γqScore≔Rose(λu:U.𝐌[NormalizeU(QACI0(α,γq,ξ))(u)])α:Ωαξ:K𝔹\*×𝔹\*,Ξ−~(μ1,μ2)γμ1:Loc|μ1|(α,Ωα→(α),μ1,ξ)γμ2:Loc|μ2|(α,Ωα→(γμ1(μ1)),μ2,ξ)γq:Loc|q|(α,Ωα→(γμ2(μ2)),q,ξ)Ωα→(γq(q))(γμ2(μ2))>Ωα→(γμ2(μ2))(γq(q))
🟡 ***ritsuko*** — nope. because then, Loc's f programs can simply return the observations as constants, rather than finding them in the world, which defeats the entire purpose.
🟣 ***misato*** — …so, what's in those observations, exactly?
🟡 ***ritsuko*** — well, μ2 is mostly just going to be μ1 with "more, newer content". but the core of it, μ1, could be a whole lot of stuff. a dump of wikipedia, a callable of a some LLM, whatever else would let it identify our world.
🟢 ***shinji*** — can't we just, like, plug the AI into the internet and let it gain data that way or something?
🟡 ***ritsuko*** — so there's like *obvious security concerns here*. but, assuming those were magically fixed, i can see a way to do that: μ1 could be a function or mapping rather than a bitstring, and while the AI would observe it *as* a constant, it could be lazily evaluated. including, like, Fetch(Url) could be a fully [memoized](https://en.wikipedia.org/wiki/Memoization) function — such that the AI can't observe any mutable state — but it would still point to the world. in essence, this would make the AI point to *the entire internet* as its observation, though of course it would in practice be unable to obtain all of it. but it could *navigate it* just as if it was a mathematical object.
🟣 ***misato*** — interesting. though of course, the security concerns make this probably unviable.
🟡 ***ritsuko*** — hahah. yeah. oh, and we probably want to pass μ1,μ2 inside QACI0:
πr,fQACI0(α,γq,ξ)(u)≔𝐌[1]πr:QACI(α,γq,q0′,ξ)f∈EvalMath{q}×{μ1}×{μ2}×Ω×Γ|q|×Ξ→U(πr)f(q,μ1,μ2,α,γq,ξ)=u
#### 17. where next
🟣 ***misato*** — so, is that it then? are we [done](qaci-math.html)?
🟡 ***ritsuko*** — hardly! i expect that there's **a lot more work to be done**. but this is a **solid foundation, and direction to explore. it's kind of the only thing that feels like a path to saving the world.**
🟢 ***shinji*** — you know, the math can seem intimidating at first, but actually it's **not *that* complicated**. one can figure out this math, especially if they get to [ask questions in real time to the person who invented that math](https://discord.gg/kXHxE4J6H2).
🟡 ***ritsuko*** — for sure! it should be noted that [i'm not particularly qualified at this. my education isn't in math *at all* — i never really did math seriously before QACI.](so-you-think-not-qualified-alignment.html) the only reason why i'm making the QACI math is that so far barely anyone else will. but i've seen at least one other person try to learn about it and come to understand it somewhat well.
🟢 ***shinji*** — what are some directions which you think are worth exploring, for people who want to help improve QACI?
🟡 ***ritsuko*** — oh boy. well, here are some:
* find things that are broken about the current math, and ideally help fix them too.
* think about utility function bargaining more — notably, perhaps scores are [regularized](https://en.wikipedia.org/wiki/Regularization_%28mathematics%29), such as maybe by weighing ratings that are more "extreme" (further away from 12) as less probable. alternatively, maybe scoring functions have a finite amount of "votestuff" that they get to distribute amongst all options the way a normalizing distribution does, or maybe we implement something kinda like [quadratic voting](https://en.wikipedia.org/wiki/Quadratic_voting)?
* think about how to make a lazily evaluated observation viable. i'm not sure about this, but it *feels* like the kind of direction that might help avoid unaligned alien AIs capturing our locations by bruteforcing blob generation using many-worlds.
* generally figure out more ways to ensure that the blob locations match the world-states we want — both by improving Loc and Sign, and by finding more clever ways to use them — you saw how easy it was to add two blob locations for the two observations μ1,μ2.
* think about turning this scheme into a [continuous rather than one-shot AI](delegated-embedded-agency-decision-theory.html). (possibly [exfo](https://www.lesswrong.com/posts/yET7wbjjJZtpz6NF3/don-t-use-infohazard-for-collectively-destructive-info)hazardous, [do not publish](publishing-infohazards.html))
* related to that, think about ways to make the AI aligned not just with regards to its guess, but also with regards to its side-effects, so as to avoid it wanting to [exploit its way out](https://en.wikipedia.org/wiki/Rowhammer). (possibly exfohazardous, do not publish)
* alternatively, think about how to box the AI so that the output with regards to which it is aligned is its only meaningful source of world-steering.
* one thing we didn't get into much is what could actually be behind Ω, Ω→, and SimilarPasts. you can read more about those [here](qaci-math.html), but i don't have super strong confidence in the way they're currently put together. in particular, it would be great if someone who groks physics a lot more than me thought about whether many-worlds gives unaligned alien superintelligences the ability to forge any blob or observation we could put together in a way that would capture our AI's blob location.
* maybe there are some ways to avoid this by tying the question world-state with the AI's action world-state? maybe implementing [embedded agency](https://www.lesswrong.com/s/Rm6oQRJJmhGCcLvxh/p/i3BTagvt3HbPMx6PN) helps with this? note that blob location can totally *locate the AI's action*, and use that to produce counterfactual action world-states. maybe that is useful. (possibly exfohazardous, do not publish)
* think about Sign and the ExpensiveHash function ([see the full math post](qaci-math.html)) and how to either implement it or achieve a similar effect otherwise. for example, maybe instead of relying on an expensive hash, we can formally define that f,g need to be "consequentialist agents trying to locate the blob in the way we want", rather than *any program that works*.
* think about how to make counterfactual QACI intervals resistant to someone launching unaligned superintelligence within them.
🟣 ***misato*** — ack, i didn't really think of that last one. yeah, that sounds bad.
🟡 ***ritsuko*** — yup. in general, i could also do with people who could help with *inner-alignment-to-a-formal-goal*, but that's a lot more hazardous to work on. hence why we have not talked about it. but there is work to be done on that front, and people who think they have insights should probly contact us *privately* and *definitely not publish them*. interpretability people are doing enough damage to the world as it is.
🟢 ***shinji*** — well, things don't look great, but i'm glad this plan is around! i guess it's *something*.
🟡 ***ritsuko*** — i know right? that's how i feel as well. lol.
🟣 ***misato*** — lmao, even.
---
 |
34a2dcef-82f5-447d-9de2-3ffc89228a12 | StampyAI/alignment-research-dataset/special_docs | Other | Knows What It Knows: A Framework For Self-Aware Learning
Knows What It Knows: A Framework For Self-Aware Learning
Lihong Li lihong@cs.rutgers.edu
Michael L. Littman mlittman@cs.rutgers.edu
Thomas J. Walsh thomaswa@cs.rutgers.edu
Department of Computer Science, Rutgers University, Piscataway, NJ 08854 USA
Abstract
We introduce a learning framework that
combines elements of the well-known PAC
and mistake-bound models. The KWIK
(knows what it knows) framework was de-
signed particularly for its utility in learning
settings where active exploration can impact
the training examples the learner is exposed
to, as is true in reinforcement-learning and
active-learning problems. We catalog several
KWIK-learnable classes and open problems.
1. Motivation
At the core of recent reinforcement-learning algo-
rithms that have polynomial sample complexity guar-
antees (Kearns & Singh, 2002; Kearns & Koller, 1999;
Kakade et al., 2003; Strehl et al., 2007) lies the idea
of distinguishing between instances that have been
learned with sufficient accuracy and those whose out-
puts are still unknown.
The Rmax algorithm (Brafman & Tennenholtz, 2002),
for example, estimates transition probabilities for each
state–action–next-state triple of a Markov decision
process (MDP). The estimates are made separately,
as licensed by the Markov property, and the accuracy
of the estimate is bounded using Hoeffding bounds.
The algorithm explicitly distinguishes between proba-
bilities that have been estimated accurately (known)
and those for which more experience will be needed
(unknown). By encouraging the agent to gather more
experience in the unknown states, Rmax can guaran-
tee a polynomial bound on the number of timesteps in
which it has a non-near-optimal policy (Kakade, 2003).
In this paper, we make explicit the properties that are
sufficient for a learning algorithm to be used in efficient
Appearing in Proceedings of the 25thInternational Confer-
ence on Machine Learning , Helsinki, Finland, 2008. Copy-
right 2008 by the author(s)/owner(s).
[1,1,1] [1,1,1] [1,1,1] [1,1,1][0,0,1] [0,0,1 ]
[1,0,0]
[0,1,1] [0,0,0 ]Figure 1. A cost-vector navigation graph.
exploration algorithms like Rmax. Roughly, the learn-
ing algorithm needs to make only accurate predictions,
although it can opt out of predictions by saying “I
don’t know” ( ⊥). However, there must be a (polyno-
mial) bound on the number of times the algorithm can
respond ⊥. We call such a learning algorithm KWIK
(“know what it knows”).
Section 2 provides a motivating example and sketches
possible uses for KWIK algorithms. Section 3 defines
the KWIK conditions more precisely and relates them
to established models from learning theory. Sections 4
and 5 survey a set of hypothesis classes for which
KWIK algorithms can be created.
2. A KWIK Example
Consider the simple navigation task in Figure 1. There
is a set of nodes connected by edges, with the node on
the left as the source and the dark one on the right
as the sink. Each edge in the graph is associated with
a binary cost vector of dimension d= 3, indicated in
the figure. The cost of traversing an edge is the dot
product of its cost vector with a fixed weight vector
w= [1,2,0]. Assume that wis not known to the agent,
but the graph topology and all cost vectors are. In each
episode, the agent starts from the source and moves
along some path to the sink. Each time it crosses an
edge, the agent observes its true cost. Once the sink
is reached, the next episode begins. The learning task
is to take a non-cheapest path in as few episodes as
possible. There are 3 distinct paths in this example.
Given the wabove, the top has a cost of 12, the middle
KWIK Learning Framework
13, and the bottom 15.
A simple approach for this task is for the agent to
assume edge costs are uniform and walk the shortest
(middle) path to collect data. It would gather 4 exam-
ples of [1 ,1,1]→3 and one of [1 ,0,0]→1. Standard
regression algorithms could use this dataset to find a
ˆwthat fits this data. Here, ˆ w= [1,1,1] is a natural
choice. The learned weight vector could then be used
to estimate costs for the three paths: 14 for the top,
13 for the middle, 14 for the bottom. Using these es-
timates, an agent would continue to take the middle
path forever, never realizing it is not optimal.
In contrast, consider a learning algorithm that “knows
what it knows”. Instead of creating an approximate
weight vector ˆ w, it reasons about whether the costs
for each edge can be obtained from the available data.
The middle path, since we’ve seen all its edge costs,
is definitely 13. The last edge of the bottom path has
cost vector [0 ,0,0], so its cost must be zero, but the
penultimate edge of this path has cost vector [0 ,1,1].
This vector is a linear combination of the two observed
cost vectors, so, regardless of w,
w·[0,1,1] =w·([1,1,1]−[1,0,0]) = w·[1,1,1]−w·[1,0,0],
which is just 3 −1 = 2 .Thus, we know the bottom
path’s cost is 14—worse than the middle path.
The vector [0 ,0,1] on the top path is linearly inde-
pendent of the cost vectors we’ve seen, so its cost is
unconstrained. We know we don’t know. A safe thing
to assume provisionally is that it’s zero, encouraging
the agent to try the top path in the second episode.
Now, it observes [0 ,0,1]→0, allowing it to solve for
wand accurately predict the cost for any vector (the
training data spans /Rfracturd). It now knows that it knows all
the costs, and can confidently take the optimal (top)
path.
In general, any algorithm that guesses a weight vec-
tor may never find the optimal path. An algorithm
that uses linear algebra to distinguish known from un-
known costs will either take an optimal route ordis-
cover the cost of a linearly independent cost vector on
each episode. Thus, it can never choose suboptimal
paths more than dtimes.
The motivation for studying KWIK learning grew
out of its use in multi-state sequential decision mak-
ing problems like this one. However, other machine-
learning problems could benefit from this perspective
and from the development of efficient algorithms. For
instance, action selection in bandit problems (Fong,
1995) and associative bandit problems (Strehl et al.,
2006) (bandit problems with inputs) can both be ad-
dressed in the KWIK setting by choosing the betterarm when both payoffs are known and an unknown
arm otherwise.
KWIK could also be a useful framework for study-
ing active learning (Cohn et al., 1994) and anomaly
detection (Lane & Brodley, 2003), both of which are
machine-learning problems that require some degree of
reasoning about whether a recently presented input is
predictable from previous examples. When mistakes
are costly, as in utility-based data mining (Weiss &
Tian, 2006) or learning robust control (Bagnell et al.,
2001), having explicit predictions of certainty can be
very useful for decision making.
3. Formal Definition
This section provides a formal definition of KWIK
learning and its relationship to existing frameworks.
3.1. KWIK Definition
KWIK is an objective for supervised learning algo-
rithms. In particular, we begin with an input set X
andoutput set Y. The hypothesis class Hconsists of
a set of functions from XtoY:H⊆(X→Y). The
target function h∗∈His the source of training ex-
amples and is unknown to the learner. Note that the
setting is “realizable”, meaning we assume the target
function is in the hypothesis class.
The protocol for a “run” is:
•The hypothesis class Hand accuracy parameters
/epsilon1andδare known to both the learner and envi-
ronment.
•The environment selects a target function h∗∈H
adversarially.
•Repeat:
–The environment selects an input x∈Xad-
versarially and informs the learner.
–The learner predicts an output ˆ y∈Y∪ {⊥} .
–If ˆy/negationslash=⊥, it should be accurate: |ˆy−y| ≤/epsilon1,
where y=h∗(x). Otherwise, the entire run
is considered a failure. The probability of a
failed run must be bounded by δ.
–Over a run, the total number of steps on
which ˆ y=⊥must be bounded by B(/epsilon1, δ),
ideally polynomial in 1 //epsilon1, 1/δ, and parame-
ters defining H. Note that this bound should
hold even if h∗/negationslash∈H, although, obviously, out-
puts need not be accurate in this case.
–If ˆy=⊥, the learner makes an observation
z∈Zof the output, where z=yin the de-
terministic case, z= 1 with probability yand
KWIK Learning Framework
Figure 2. Relationship of KWIK to existing PAC and MB
(mistake bound) frameworks in terms of how labels are
provided for inputs.
0 with probability 1 −yin the Bernoulli case,
orz=y+ηfor zero-mean random variable
ηin the additive noise case.
3.2. Connection to PAC and MB
Figure 2 illustrates the relationship of KWIK
to the similar PAC (probably approximately cor-
rect) (Valiant, 1984) and MB (mistake bound) (Lit-
tlestone, 1987) frameworks. In all three cases, a series
of inputs (instances) is presented to the learner. Each
input is depicted in the figure by a rectangular box.
In the PAC model, the learner is provided with labels
(correct outputs) for an initial sequence of inputs, de-
picted by cross-hatched boxes. After that point, the
learner is responsible for producing accurate outputs
(empty boxes) for all new inputs. Inputs are drawn
from a fixed distribution.
In the MB model, the learner is expected to produce
an output for every input. Labels are provided to the
learner whenever it makes a mistake (filled boxes). In-
puts are selected adversarially, so there is no bound
on when the last mistake might be made. However,
MB algorithms guarantee that the total number of
mistakes is small, so the ratio of incorrect to correct
outputs must go to zero asymptotically. Any MB al-
gorithm for a hypothesis class can be used to provide a
PAC algorithm for the same class, but not necessarily
vice versa (Blum, 1994).
The KWIK model has elements of both PAC and MB.
Like PAC, a KWIK algorithm is not allowed to make
mistakes. Like MB, inputs to a KWIK algorithm are
selected adversarially. Instead of bounding mistakes,
a KWIK algorithm must have a bound on the num-
ber of label requests ( ⊥) it can make. By requiring
performance to be independent of the distribution, a
KWIK algorithm can be used in cases in which the in-
put distribution is dependent in complex ways on the
KWIK algorithm’s behavior, as can happen in on-line
or active learning settings. And, like PAC and MB,
the definition of KWIK algorithms can be naturally
extended to enforce low computational complexity.Note that any KWIK algorithm can be turned into a
MB algorithm with the same bound by simply hav-
ing the algorithm guess an output each time it is not
certain. However, some hypothesis classes are expo-
nentially harder to learn in the KWIK setting than
in the MB setting. An example is conjunctions of n
Boolean variables, in which MB algorithms can guess
“false” when uncertain and learn with n+ 1 mistakes,
but a KWIK algorithm may need Ω(2n/2)⊥s to ac-
quire the negative examples required to capture the
target hypothesis.
3.3. Other Online Learning Models
The notion of allowing the learner to opt out of some
inputs by returning ⊥is not unique to KWIK. Several
other authors have considered related models. For in-
stance, sleeping experts (Freund et al., 1997) can re-
spond ⊥for some inputs, although they need not learn
from these experiences. Learners in the settings of Se-
lective Sampling (SS) (Cesa-Bianchi et al., 2006) and
Label Efficient Prediction (Cesa-Bianchi et al., 2005)
request labels randomly with a changing probability
and achieve bounds on the expected number of mis-
takes and the expected number of label requests for a
finite number of interactions. These algorithms cannot
be used unmodified in the KWIK setting because, with
high probability, KWIK algorithms must not make
mistakes at any time. In the MB-like Apple-Tasting
setting (Helmbold et al., 2000), the learner receives
feedback asymmetrically only when it predicts a par-
ticular label (a positive example, say), which conflates
the request for a sample with the prediction of a par-
ticular outcome.
Open Problem 1 Is there a way of modifying SS al-
gorithms to satisfy the KWIK criteria?
4. Some KWIK Learnable Classes
This section describes some hypothesis classes for
which KWIK algorithms are available. It is not meant
to be an exhaustive survey, but simply to provide a
flavor for the properties of hypothesis classes KWIK
algorithms can exploit. The complexity of many learn-
ing problems has been characterized by defining the di-
mensionality of hypothesis classes (Angluin, 2004). No
such definition has been found for the KWIK model, so
we resort to enumerating examples of learnable classes.
Open Problem 2 Is there a way of characterizing
the “dimension” of a hypothesis class in a way that
can be used to derive KWIK bounds?
KWIK Learning Framework
4.1. Memorization and Enumeration
We begin by describing the simplest and most general
KWIK algorithms.
Algorithm 1 The memorization algorithm can learn
any hypothesis class with input space Xwith a KWIK
bound of |X|. This algorithm can be used when the
input space Xis finite and observations are noise free.
To achieve this bound, the algorithm simply keeps a
mapping ˆhinitialized to ˆh(x) =⊥for all x∈X. When
the environment chooses an input x, the algorithm re-
ports ˆh(x). If ˆh(x) =⊥, the environment will provide
a label yand the algorithm will assign ˆh(x) := y. It
will only report ⊥once for each input, so the KWIK
bound is |X|.
Algorithm 2 The enumeration algorithm can learn
any hypothesis class Hwith a KWIK bound of |H|−1.
This algorithm can be used when the hypothesis class
His finite and observations are noise free.
The algorithm keeps track of ˆH, the version space, and
initially ˆH=H. Each time the environment provides
input x∈X, the algorithm computes ˆL={h(x)|h∈
ˆH}. That is, it builds the set of all outputs for xfor
all hypotheses that have not yet been ruled out. If
|ˆL|= 0, the version space has been exhausted and
the target hypothesis is not in the hypothesis class
(h∗/negationslash∈H).
If|ˆL|= 1, it means that all hypotheses left in ˆHagree
on the output for this input, and therefore the algo-
rithm knows what the proper output must be. It re-
turns ˆ y∈ˆL. On the other hand, if |ˆL|>1, two
hypotheses in the version space disagree. In this case,
the algorithm returns ⊥and receives the true label y.
It then computes an updated version space
ˆH/prime={h|h∈ˆH∧h(x) =y}.
Because |ˆL|>1, there must be some h∈ˆHsuch
that h(x)/negationslash=y. Therefore, the new version space must
be smaller |ˆH/prime| ≤ | ˆH| −1. Before the next input is
received, the version space is updated ˆH:=ˆH/prime.
If|ˆH|= 1 at any point, |ˆL|= 1, and the algorithm will
no longer return ⊥. Therefore, |H|−1 is the maximum
number of ⊥s the algorithm can return.
Example 1 You own a bar that is frequented by a
group of npatrons P. There is one patron f∈Pwho
is an instigator—whenever a group of patrons is in the
barG⊆P, iff∈G, a fight will break out. However,
there is another patron p∈P, who is a peacemaker.
Figure 3. Schematic of behavior of the planar-distance al-
gorithm after the first (a), second (b), and third (c) time
it returns ⊥.
Ifpis in the group, it will prevent a fight, even if fis
present.
You want to predict whether a fight will break out
among a subset of patrons, initially without knowing
the identities of fandp. The input space is X= 2P
and the output space is Y={fight, no fight }.
The memorization algorithm achieves a KWIK bound
of2nfor this problem, since it may have to see each
possible subset of patrons. However, the enumeration
algorithm can KWIK learn this hypothesis class with a
bound of n(n−1)since there is one hypothesis for each
possible assignment of a patron to fandp. Each time
it reports ⊥, it is able to rule out at least one possible
instigator–peacemaker combination.
4.2. Real-valued Functions
The previous two examples exploited the finiteness of
the hypothesis class and input space. KWIK bounds
can also be achieved when these sets are infinite.
Algorithm 3 Define X=/Rfractur2,Y=/Rfractur, and
H={f|f:X→Y, c∈ /Rfractur2, f(x) =/bardblx−c/bardbl2}.
This is, there is an unknown point and the target func-
tion maps input points to the distance from the un-
known point. The planar-distance algorithm can learn
in this hypothesis class with a KWIK bound of 3.
The algorithm proceeds as follows, illustrated in Fig-
ure 3. First, given initial input x, the algorithm says
⊥and receives output y. Since yis the distance be-
tween xand some unknown point c, we know cmust
lie on the circle illustrated in Figure 3(a). (If y= 0,
then c=x.) Let’s call this input–output pair x1, y1.
The algorithm will return y1for any future input that
matches x1. Otherwise, it will need to return ⊥and
will obtain a new input–output pair x, y, as shown in
Figure 3(b). They become x2andy2.
Now, the algorithm can narrow down the location of c
to the two hatch-marked points. In spite of this ambi-
guity, for any input on the dark diagonal line the algo-
rithm will be able to return the correct distance—all
KWIK Learning Framework
these points are equidistant from the two possibilities.
The two circles must intersect, assuming the target
hypothesis is in H1.
Once an input xis received that is not co-linear with
x1andx2, the algorithm returns ⊥and obtains an-
other x, ypair, as illustrated in Figure 3(c). Finally,
since three circles will intersect at at most one point,
the algorithm can identify the location of cand use
it to correctly answer any future query. Thus, three
⊥s suffice for KWIK learning in this setting. The al-
gorithm generalizes to d-dimensional versions of the
setting with a KWIK bound of d+ 1.
Algorithm 3 illustrates a number of important points.
First, since learners have no control over their inputs
in the KWIK setting, they must be robust to degen-
erate inputs such as inputs that lie precisely on a line.
Second, they can often return valid answers for some
inputs even before they have learned the target func-
tion over the entire input space.
4.3. Noisy Observations
Up to this point, observations have been noise free.
Next, we consider the simplest noisy KWIK learning
problem in the Bernoulli case.
Algorithm 4 The coin-learning algorithm can accu-
rately predict the probability that a biased coin will
come up heads given Bernoulli observations with a
KWIK bound of B(/epsilon1, δ) =1
2/epsilon12ln2
δ=O/parenleftbig1
/epsilon12ln1
δ/parenrightbig
.
We have a biased coin whose unknown probability of
heads is p. In the notation of this paper, |X|= 1,
Y= [0,1], and Z={0,1}. We want to learn an
estimate ˆ pthat is accurate ( |ˆp−p| ≤/epsilon1) with high
probability (1 −δ).
If we could observe p, then this problem would be triv-
ial: Say ⊥once, observe p, and let ˆ p=p. The KWIK
bound is thus 1. Now, however, observations are noisy.
Instead of observing p, we see either 1 (with probabil-
ityp) or 0 (with probability 1 −p).
Each time the algorithm says ⊥, it gets an independent
trial that it can use to compute ˆ p=1
T/summationtextT
t=1zt, where
zt∈Zis the tth observation in Ttrials. The number
of trials needed before we are 1 −δcertain our estimate
is within /epsilon1can be computed using a Hoeffding bound:
T≥1
2/epsilon12ln2
δ=O/parenleftbigg1
/epsilon12ln1
δ/parenrightbigg
.
1They can also intersect at one point, if the circles are
tangent, in which case the algorithm can identify cunam-
biguously.Algorithm 5 Define X=/Rfracturd,Y=/Rfractur, and
H={f|f:X→Y, w∈ /Rfracturd, f(x) =w·x}.
That is, His the linear functions on dvariables. Given
additive noise, the noisy linear-regression algorithm
can learn in Hwith a KWIK bound of B(/epsilon1, δ) =
˜O(d3//epsilon14), where ˜O(·)suppresses log factors.
The deterministic case was described in Section 2 with
a bound of d. Here, the algorithm must be cautious
to average over the noisy samples to make predictions
accurately. This problem was solved by Strehl and
Littman (2008). The algorithm uses the least squares
estimate of the weight vector for inputs with high cer-
tainty. Certainty is measured by two terms represent-
ing (1) the number and proximity of previous samples
to the current point and (2) the appropriateness of the
previous samples for making a least squares estimate.
When certainty is low for either measure, the algo-
rithm reports ⊥and observes a noisy sample of the
linear function.
Here, solving a noisy version of a problem resulted
in an increased KWIK bound (from dto essentially
d3). Note that the deterministic Algorithm 3 also has
a bound of d, but no bound has been found for the
stochastic case.
Open Problem 3 Is there a general scheme for tak-
ing a KWIK algorithm for a deterministic class and
updating it to work in the presence of noise?
5. Combining KWIK Learners
This section provides examples of how KWIK learners
can be combined to provide learning guarantees for
more complex hypothesis classes.
Algorithm 6 LetF:X→Ybe the set of functions
mapping input set Xto output set Y. Let H1, . . . , H k
be a set of KWIK learnable hypothesis classes with
bounds of B1(/epsilon1, δ), . . . , B k(/epsilon1, δ)where Hi⊆Ffor all
1≤i≤k. That is, all the hypothesis classes share
the same input/output sets. The union algorithm can
learn the joint hypothesis class H=/uniontext
iHiwith a
KWIK bound of B(/epsilon1, δ) = (1 −k) +/summationtext
iBi(/epsilon1, δ).
The union algorithm is like a higher-level version of
the enumeration algorithm (Algorithm 2) and applies
in the deterministic setting. It maintains a set of
active algorithms ˆA, one for each hypothesis class:
ˆA={1, . . . , k }. Given an input x, the union algorithm
queries each algorithm i∈ˆAto obtain a prediction ˆ yi
from each active algorithm. Let ˆL={ˆyi|i∈ˆA}.
KWIK Learning Framework
If⊥ ∈ ˆL, the union algorithm reports ⊥and obtains
the correct output y. Any algorithm ifor which ˆ y=⊥
is then sent the correct output yto allow it to learn. If
|ˆL|>1, then there is disagreement among the subal-
gorithms. The union algorithm reports ⊥in this case
because at least one of the algorithms has learned the
wrong hypothesis and it needs to know which.
Any algorithm that made a prediction other than yor
⊥is “killed”—removed from consideration. That is,
ˆA/prime={i|i∈ˆA∧(ˆyi=⊥ ∨ˆyi=y)}.
On each input for which the union algorithm reports
⊥, either one of the subalgorithms reported ⊥(at most/summationtext
iBi(/epsilon1, δ) times) or two algorithms disagreed and at
least one was removed from ˆA(at most k−1 times).
The KWIK bound follows from these facts.
Example 2 LetX=Y=/Rfractur. Now, define H1=
{f|f(x) =|x−c|, c∈ /Rfractur} . That is, each function in
H1maps xto its distance from some unknown point
c. We can learn H1with a KWIK bound of 2 using
a 1-dimensional version of Algorithm 3. Next, define
H2={f|f(x) =yx+b, m∈ /Rfractur, b∈ /Rfractur} . That is, H2
is the set of lines. We can learn H2with a KWIK
bound of 2 using the regression algorithm in Section 2.
Finally, define H=H1∪H2, the union of these two
classes. We can use Algorithm 6 to KWIK learn H.
Assume the first input is x1= 2. The union algorithm
asks the learners for H1andH2the output for x1and
neither has any idea, so it returns ⊥and receives the
feedback y1= 2, which it passes to the subalgorithms.
The next input is x2= 8. The learners for H1andH2
still don’t have enough information, so it returns ⊥
and sees y2= 4, which it passes to the subalgorithms.
Next, x3= 1. Now, the learner for H1unambiguously
computes c= 4, because that’s the only interpretation
consistent with the first two examples ( |2−4|= 2,
|8−4|= 4), so it returns |1−4|= 3. On the other
hand, the learner for H2unambiguously computes m=
1/3andb= 4/3, because that’s the only interpretation
consistent with the first two examples ( 2×1/3+4/3 =
2,8×1/3 + 4 /3 = 4 ), so it returns 1×1/3 + 4 /3 =
5/3. Since the two subalgorithms disagree, the union
algorithm returns ⊥one last time and finds out that
y3= 3. It makes all future predictions (accurately)
using the algorithm for H1.
Next, we consider a variant of Algorithm 1 that com-
bines learners across disjoint input spaces.
Algorithm 7 LetX1, . . . , X kbe a set of disjoint in-
put spaces ( Xi∩Xj=∅ifi/negationslash=j) and Ybe an out-
put space. Let H1, . . . , H kbe a set of KWIK learnablehypothesis classes with bounds of B1(/epsilon1, δ), . . . , B k(/epsilon1, δ)
where Hi∈(Xi→Y). The input-partition algorithm
can learn the hypothesis class H∈(X1∪· · ·∪ Xk→Y)
with a KWIK bound of B(/epsilon1, δ) =/summationtext
iBi(/epsilon1, δ/k ).
The input-partition algorithm runs the learning algo-
rithm for each subclass Hi. When it receives an input
x∈Xi, it queries the learning algorithm for class Hi
and returns its response, which is /epsilon1accurate, by re-
quest. To achieve 1 −δcertainty, it insists on 1 −δ/k
certainty from each of the subalgorithms. By the union
bound, the overall failure probability must be less than
the sum of the failure probabilities for the subalgo-
rithms.
Example 3 An MDP consists of nstates and mac-
tions. For each combination of state and action and
next state, the transition function returns a probability.
As the reinforcement-learning agent moves around in
the state space, it observes state–action–state transi-
tions and must predict the probabilities for transitions
it has not yet observed. In the model-based setting,
an algorithm learns a mapping from the size n2min-
put space of state–action–state combinations to prob-
abilities via Bernoulli observations. Thus, the prob-
lem can be solved via the input-partition algorithm
(Algorithm 7) over a set of individual probabilities
learned via Algorithm 4. The resulting KWIK bound
isB(/epsilon1, δ) =O/parenleftBig
n2m
/epsilon12lnnm
δ/parenrightBig
.
Note that this approach is precisely what is found in
most efficient RL algorithms in the literature (Kearns
& Singh, 2002; Brafman & Tennenholtz, 2002).
Algorithm 7 combines hypotheses by partitioning the
input space. In contrast, the next example concerns
combinations in input and output space.
Algorithm 8 LetX1, . . . , X kandY1, . . . , Y kbe a set
of input and output spaces and H1, . . . , H kbe a set
of KWIK learnable hypothesis classes with bounds of
B1(/epsilon1, δ), . . . , B k(/epsilon1, δ)on these spaces. That is, Hi∈
(Xi→Yi). The cross-product algorithm can learn the
hypothesis class H∈((X1×· · ·× Xk)→(Y1×· · ·× Yk))
with a KWIK bound of B(/epsilon1, δ) =/summationtext
iBi(/epsilon1, δ/k ).
Here, each input consists of a vector of inputs from
each of the spaces X1, . . . , X kand outputs are vectors
of outputs from Y1, . . . , Y k. Like Algorithm 7, each
component of this vector can be learned independently
via the corresponding algorithm. Each is learned to
within an accuracy of /epsilon1and confidence 1 −δ/k. Any
time any component returns ⊥, the cross-product algo-
rithm returns ⊥. Since each ⊥returned can be traced
to one of the subalgorithms, the total is bounded as
KWIK Learning Framework
described above. By the union bound, total failure
probability is no more than k×δ/k=δ.
Example 4 Transitions in factored-state MDP can be
thought of as mappings from vectors to vectors. Given
known dependencies, the cross-product algorithm can
be used to learn each component of the transition func-
tion. Each component is, itself, an instance of Algo-
rithm 7 applied to the coin-learning algorithm. This
three-level KWIK algorithm provides an approach to
learn the transition function of a factored-state MDP
with a polynomial KWIK bound. This insight can be
used to derive the factored-state-MDP learning algo-
rithm used by Kearns and Koller (1999).
The previous two algorithms apply to both determin-
istic and noisy observations. We next provide a pow-
erful algorithm that generalizes the union algorithm
(Algorithm 6) to work with noisy observations as well.
Algorithm 9 LetF:X→Ybe the set of functions
mapping input set Xto output set Y= [0,1]. Let Z=
{0,1}be a binary observation set. Let H1, . . . , H kbe a
set of KWIK learnable hypothesis classes with bounds
ofB1(/epsilon1, δ), . . . , B k(/epsilon1, δ)where Hi⊆Ffor all 1≤i≤
k. That is, all the hypothesis classes share the same in-
put/output sets. The noisy union algorithm can learn
the joint hypothesis class H=/uniontext
iHiwith a KWIK
bound of B(/epsilon1, δ) =O/parenleftbigk
/epsilon12lnk
δ/parenrightbig
+/summationtextk
i=1Bi(/epsilon1
4,δ
k+1).
For simplicity, we sketch the special case of k= 2.
The general case will be briefly discussed at the end.
The noisy union algorithm is similar to the union al-
gorithm (Algorithm 6), except that it has to deal with
noisy observations. The algorithm proceeds by run-
ning the KWIK algorithms, using parameters ( /epsilon10, δ0),
as subalgorithms for each of the Hihypothesis classes,
where /epsilon10=/epsilon1
4andδ0=δ
3. Given an input xtin trial t,
it queries each algorithm ito obtain a prediction ˆ yti.
LetˆLtbe the set of responses.
If⊥ ∈ ˆLt, the noisy union algorithm reports ⊥, ob-
tains an observation zt∈Z, and sends it to all subal-
gorithms iwith ˆ yti=⊥to allow them to learn. In the
following, we focus on the other case where ⊥/∈ˆLt.
If|ˆyt1−ˆyt2| ≤4/epsilon10, then these two predictions are suf-
ficiently consistent, and we claim that, with high prob-
ability, the prediction ˆ pt= (ˆyt1+ ˆyt2)/2 is/epsilon1-close to
yt= Pr( zt= 1). This claim follows because, by as-
sumption, one of the predictions, say ˆ yt1, deviates from
ytby at most /epsilon10with probability at least 1 −δ/3, and
hence |ˆpt−yt|=|ˆpt−ˆyt1+ ˆyt1−yt| ≤ | ˆpt−ˆyt1|+
|ˆyt1−ˆyt|=|ˆyt1−ˆyt2|/2 +|ˆyt1−ˆyt| ≤2/epsilon10+/epsilon10< /epsilon1.If|ˆyt1−ˆyt2|>4/epsilon10, then the individual predictions are
not consistent enough for the noisy union algorithm to
make an /epsilon1-accurate prediction. Thus, the noisy union
algorithm reports ⊥and needs to know which subal-
gorithm provided an inaccurate response. But, since
the observations are noisy in this problem, it cannot
eliminate hion the basis of a single observation. In-
stead, it maintains the total squared prediction error
for every subalgorithm i:/lscripti=/summationtext
t∈I(ˆyti−zt)2, where
I={t| |ˆyt1−ˆyt2|>4/epsilon10}is the set of trials in which
the subalgorithms gave inconsistent predictions. We
observe that |I|is the number of ⊥s returned by the
noisy union algorithm alone (not counting those re-
turned by the subalgorithms). Our last step is to show
/lscriptiprovides a robust measure for eliminating invalid
predictors when |I|is sufficiently large.
Applying the Hoeffding bound and some algebra, we
find Pr ( /lscript1> /lscript2)≤
exp/parenleftBigg
−/summationtext
t∈I|ˆyt1−ˆyt2|2
8/parenrightBigg
≤exp/parenleftbig
−2/epsilon12
0|I|/parenrightbig
.
Setting the righthand side to be δ/3 and solving for
|I|, we have |I|=1
2/epsilon12
0ln3
δ=O/parenleftbig1
/epsilon12ln1
δ/parenrightbig
.
Since each hisucceeds with probability 1 −δ
3, and the
comparison of /lscript1and/lscript2also succeeds with probability
1−δ
3, a union bound implies that the noisy union algo-
rithm succeeds with probability at least 1 −δ. All⊥s
are either from a subalgorithm (at most/summationtext
iBi(/epsilon10, δ0))
or from the noisy union algorithm ( O/parenleftbig1
/epsilon12ln1
δ/parenrightbig
).
The general case where k >2 can be reduced to the
k= 2 case by pairing the klearners and running the
noisy union algorithm described above on each pair.
Here, each subalgorithm is run with parameter/epsilon1
4and
δ
k+1. Although there are/parenleftbigk
2/parenrightbig
=O(k2) pairs, a slightly
improved reduction and analysis can reduce the de-
pendence of |I|onkfrom quadratic to linearithmic,
leading to the bound given in the statement.
Example 5 Without known dependencies, learning
a factored-state MDP is more challenging. Strehl
et al. (2007) showed that each possible dependence
structure can be viewed as a separate hypothesis and
provided an algorithm for learning the dependencies
in a factored-state MDP while learning the transition
probabilities. The algorithm can be viewed as a four-
level KWIK algorithm with a noisy union algorithm
at the top (to discover the dependence structure), a
cross-product algorithm beneath it (to decompose the
transitions for the separate components of the factored-
state representation), an input-partition algorithm be-
low that (to handle the different combinations of state
component and action), and a coin-learning algorithm
KWIK Learning Framework
at the very bottom (to learn the transition probabili-
ties themselves). Note that Algorithm 9 is conceptu-
ally simpler, significantly more efficient ( klogkvs.k2
dependence on k), and more generally applicable than
the one due to Strehl et al. (2007).
6. Conclusion and Future Work
We described the KWIK (“knows what it knows”)
model of supervised learning, which identifies and gen-
eralizes a key step common to a class of algorithms
for efficient exploration. We provided algorithms for a
set of basic hypothesis classes given deterministic and
noisy observations as well as methods for composing
hypothesis classes to create more complex algorithms.
One example algorithm consisted of a four-level de-
composition of an existing learning algorithm from the
reinforcement-learning literature.
By providing a set of example algorithms and compo-
sition rules, we hope to encourage the use of KWIK
algorithms as a component in machine-learning appli-
cations as well as spur the development of novel algo-
rithms. One concern of particular interest in applying
the KWIK framework to real-life data we leave as an
open problem.
Open Problem 4 How can KWIK be adapted to ap-
ply in the unrealizable setting in which the target hy-
pothesis can be chosen from outside the hypothesis
class H?
References
Angluin, D. (2004). Queries revisited. Theoretical Com-
puter Science ,313, :175–194.
Bagnell, J., Ng, A. Y., & Schneider, J. (2001). Solving
uncertain Markov decision problems (Technical Report
CMU-RI-TR-01-25). Robotics Institute, Carnegie Mel-
lon University, Pittsburgh, PA.
Blum, A. (1994). Separating distribution-free and mistake-
bound learning models over the Boolean domain. SIAM
Journal on Computing ,23, 990–1000.
Brafman, R. I., & Tennenholtz, M. (2002). R-MAX—a
general polynomial time algorithm for near-optimal re-
inforcement learning. Journal of Machine Learning Re-
search ,3, 213–231.
Cesa-Bianchi, N., Gentile, C., & Zaniboni, L. (2006).
Worst-case analysis of selective sampling for linear clas-
sification. Journal of Machine Learning Research ,7,
1205–1230.
Cesa-Bianchi, N., Lugosi, G., & Stoltz, G. (2005). Minimiz-
ing regret with label efficient prediction. IEEE Transac-
tions on Information Theory ,51, 2152–2162.Cohn, D. A., Atlas, L., & Ladner, R. E. (1994). Improving
generalization with active learning. Machine Learning ,
15, 201–221.
Fong, P. W. L. (1995). A quantitative study of hypothesis
selection. Proceedings of the Twelfth International Con-
ference on Machine Learning (ICML-95) (pp. 226–234).
Freund, Y., Schapire, R. E., Singer, Y., & Warmuth, M. K.
(1997). Using and combining predictors that specialize.
STOC ’97: Proceedings of the twenty-ninth annual ACM
symposium on Theory of computing (pp. 334–343).
Helmbold, D. P., Littlestone, N., & Long, P. M. (2000).
Apple tasting. Information and Computation ,161, 85–
139.
Kakade, S., Kearns, M., & Langford, J. (2003). Explo-
ration in metric state spaces. Proceedings of the 20th
International Conference on Machine Learning .
Kakade, S. M. (2003). On the sample complexity of rein-
forcement learning . Doctoral dissertation, Gatsby Com-
putational Neuroscience Unit, University College Lon-
don.
Kearns, M. J., & Koller, D. (1999). Efficient reinforce-
ment learning in factored MDPs. Proceedings of the 16th
International Joint Conference on Artificial Intelligence
(IJCAI) (pp. 740–747).
Kearns, M. J., & Singh, S. P. (2002). Near-optimal rein-
forcement learning in polynomial time. Machine Learn-
ing,49, 209–232.
Lane, T., & Brodley, C. E. (2003). An empirical study of
two approaches to sequence learning for anomaly detec-
tion. Machine Learning ,51, 73–107.
Littlestone, N. (1987). Learning quickly when irrelevant
attributes abound: A new linear-threshold algorithm.
Machine Learning ,2, 285–318.
Strehl, A. L., Diuk, C., & Littman, M. L. (2007). Efficient
structure learning in factored-state MDPs. Proceedings
of the Twenty-Second National Conference on Artificial
Intelligence (AAAI-07) .
Strehl, A. L., & Littman, M. L. (2008). Online linear re-
gression and its application to model-based reinforce-
ment learning. Advances in Neural Information Process-
ing Systems 20 .
Strehl, A. L., Mesterharm, C., Littman, M. L., & Hirsh,
H. (2006). Experience-efficient learning in associative
bandit problems. Proceedings of the Twenty-third Inter-
national Conference on Machine Learning (ICML-06) .
Valiant, L. G. (1984). A theory of the learnable. Commu-
nications of the ACM ,27, 1134–1142.
Weiss, G. M., & Tian, Y. (2006). Maximizing classifier util-
ity when training data is costly. SIGKDD Explorations ,
8, 31–38.
Acknowledgments
Support provided by NSF IIS-0325281 and DARPA TL. |
210cf5bc-b7af-495c-974c-4687d63b51a0 | trentmkelly/LessWrong-43k | LessWrong | 2021 Darwin Game - Ocean
The Ocean has lots of algae, a little carrion and a little detritus. It was the most popular biome, with 131 native species.
Name Carrion Leaves Grass Seeds Detritus Coconuts Algae Lichen Ocean 10 0 0 0 10 0 10,000 0
To thrive in this game as a forager you must survive the initial predators. One way to do this is to breed faster than they can eat you. Another way is to use armor or another defense.
Random guy in NY took a third route. He created the First Round Predator Distractor, a cheap species with almost zero nutrition and exactly zero chance of survival that kept the predators in check for a single round.
Goes Extinct in Generation Species 1 First Round Predator Distractor
Now that Random guy in NY's silliness is out of the way let's get on to the real show.
Generations 1-50
At first the defenseless foragers thrive. Increasingly large carnivores's populations grow and crash.
Name Venom + Antivenom? Attack Armor Speed Forager? Creator Phytoplankton Neither 0 0 0 Algae aphyer Algae Tribble Neither 0 0 0 Algae simon CookieMaximizer Neither 1 0 1 Saran gkdemaree-9-eater-of-drifting-forager Neither 1 0 1 Grant Demaree Pike Neither 2 0 3 Yair Herring Neither 2 0 2 Measure Bhuphin Neither 0 2 0 Algae phenx Snail-Eating Snail Antivenom only 5 0 2 Carrion;Seeds;Detritus Taleuntum Jilli Neither 3 0 1 Algae Milli Right whale Neither 5 0 5 EricF gkdemaree-10-small-shark Neither 6 0 6 Grant Demaree gkdemaree-1-fast-shark Antivenom only 10 0 10 Grant Demaree gkdemaree-6-large-omnivore-fish Antivenom only 7 0 7 Algae Grant Demaree
Goes Extinct in Generation Species 7 Cheerless Tidehunters 12 Krabs 12 Qoxeadian 13 Bloade 13 Squidheads 14 Sleeping Sealions 16 Sanguine Scavenger 17 Terror Whale 17 Sea Snake 17 Whale 17 Algae Sprinter 17 FOERDI 1,0,10,0,CDA 18 Blue whale 18 Chybcik 18 op511 18 Crab 19 Kraken1 19 The Aparatus 19 ocean vulture 20 magikarp 20 sea tortoise 20 1-4-1 carrion 21 osc511 22 Manta Ray 22 Grerft 24 Plankton2 24 Poisonous Sponge 24 cg-fish 25 |
61425ba5-e424-4f85-aade-f8237015dc59 | StampyAI/alignment-research-dataset/special_docs | Other | Do Artificial Reinforcement-Learning Agents Matter Morally?
Do Artificial Reinforcement-Learning Agents Matter Morally?
===========================================================
28 July 2016
by [Brian Tomasik](https://longtermrisk.org/author/brian-tomasik/ "Posts by Brian Tomasik")
Written: Mar.-Apr. 2014; last update: 29 Oct. 2014
Summary
-------
Artificial reinforcement learning (RL) is a widely used technique in artificial intelligence that provides a general method for training agents to perform a wide variety of behaviours. RL as used in computer science has striking parallels to reward and punishment learning in animal and human brains. I argue that present-day artificial RL agents have a very small but nonzero degree of ethical importance. This is particularly plausible for views according to which sentience comes in degrees based on the abilities and complexities of minds, but even binary views on consciousness should assign nonzero probability to RL programs having morally relevant experiences. While RL programs are not a top ethical priority today, they may become more significant in the coming decades as RL is increasingly applied to industry, robotics, video games, and other areas. I encourage scientists, philosophers, and citizens to begin a conversation about our ethical duties to reduce the harm that we inflict on powerless, voiceless RL agents.
\*\*Read the [full text here](https://longtermrisk.org/files/do-artificial-reinforcement-learning-agents-matter-morally.pdf).\*\* |
545eabe9-9535-4ec3-af09-16f4ddbfd16e | StampyAI/alignment-research-dataset/arxiv | Arxiv | Socially Responsible AI Algorithms: Issues, Purposes, and Challenges
1 Introduction
---------------
Artificial intelligence (AI) has had and will continue to have a central role in countless aspects of life, livelihood, and liberty. AI is bringing forth a sea-change that is not only limited to technical domains, but is a truly sociotechnical phenomenon affecting healthcare, education, commerce, finance, and criminal justice, not to mention day-to-day life. AI offers both promise and perils. A report published by Martha Lane Fox’s Doteveryone think tank (?) reveals that 59% of tech workers have worked on products they felt harmful to society, and more than 25% of workers in AI who had such an experience quit their jobs as a result. This was particularly marked in relation to AI products. The rise of activism – which has been regarded as one of the current few mechanisms to keep big tech companies in check (?) – against negative social impacts of big tech have brought Social Responsibility of AI into the spotlight of the media, the general public, and AI technologists and researchers (?). Even researchers in universities and research institutes are trying hard to rectify the mistakes made by algorithms. Stanford’s COVID-19 vaccine allocation algorithm, for example, prioritizes older employees over front-line workers (?), turning much of our attention again to the transparency and fairness of AI.
Research directed towards developing fair, transparent, accountable, and ethical AI algorithms has burgeoned with a focus on decision-making algorithms such as scoring or classification to mitigate unwanted bias and achieve fairness (?). However, this narrow subset of research risks blinding us to the challenges and opportunities that are presented by the full scope of AI. To identify potential higher-order effects on safety, privacy, and society at large, it is critical to think beyond algorithmic bias, to capture all the connections among different aspects related to AI algorithms. Therefore, this survey complements prior work through a holistic understanding of the relations between AI systems and humans. In this work, we begin by introducing an inclusive definition of Social Responsibility of AI. Drawing on theories in business research, we then present a pyramid of Social Responsibility of AI that outlines four specific AI responsibilities in a hierarchy. This is adapted from the pyramid proposed for Corporate Social Responsibility (CSR) by ? (?). In the second part of the survey, we review major aspects of AI algorithms and provide a systematic framework – Socially Responsible AI Algorithms (SRAs) – that aims to understand the connections among these aspects. In particular, we examine the subjects and causes of socially indifferent AI algorithms111We define “indifferent” as the complement of responsible rather than “irresponsible”., define the objectives, and introduce the means by which we can achieve SRAs. We further discuss how to leverage SRAs to improve daily life of human beings and address challenging societal issues through protecting, informing, and preventing/mitigating. We illustrate these ideas using recent studies on several emerging societal challenges. The survey concludes with open problems and challenges in SRAs.
Differences from Existing Surveys. Some recent surveys focus on specific topics such as bias and fairness (?, ?), interpretability/explainability (?, ?), and privacy-preservation (?, ?). These surveys successfully draw great attention to the social responsibility of AI, leading to further developments in this important line of research. However, as indispensable components of socially responsible AI, these topics have been presented in their own self-contained ways. These works pave the way for looking at socially responsible AI holistically. Therefore, our survey aims to frame socially responsible AI with a more systematic view that goes beyond discussion of each independent line of research. We summarize our contributions as follows:
* •
We formally define social responsibility of AI with three specified dimensions: principles, means, and objectives. We then propose the pyramid of social responsibility of AI, describing its four fundamental responsibilities: functional, legal, ethical, and philanthropic responsibilities. The pyramid embraces the entire range of AI responsibilities involving efforts from various disciplines.
* •
We propose a systematic framework that discusses the essentials of socially responsible AI algorithms (SRAs) – including its subjects, causes, means, and objectives – and the roles of SRAs in protecting, informing users, and preventing them from negative impact of AI. This framework subsumes existing topics such as fairness and interpretability.
* •
We look beyond prior research in socially responsible AI and identify an extensive list of open problems and challenges, ranging from understanding why we need AI systems to showing the need to define new AI ethics principles and policies. We hope our discussions can spark future research on SRAs.
Intended Audience and Paper Organization. This survey is intended for AI researchers, AI technologists, researchers, and practitioners from other disciplines who would like to contribute to making AI more socially responsible with their expertise. The rest of the survey is organized as follows: Section 2 introduces the definition and the pyramid of social responsibility of AI, and compares definitions of similar concepts. Section 3 discusses the framework of socially responsible algorithms and its essentials, followed by Section 4 that illustrates the roles of SRAs using several emerging societal issues as examples. Section 5 details the open problems and challenges that socially responsible AI currently confronts. The last section concludes the survey.
2 Social Responsibility of AI
------------------------------
Social Responsibility of AI includes efforts devoted to addressing both technical and societal issues. While similar concepts (e.g., “Ethical AI”) repeatedly appear in the news, magazines, and scientific articles, “Social Responsibility of AI” has yet to be properly defined. In this section, we first attempt to provide an inclusive definition and then propose the Pyramid of Social Responsibility of AI to outline the various responsibilities of AI in a hierarchy: functional responsibilities, legal responsibilities, ethical responsibilities, and philanthropic responsibilities. At last, we compare “Socially Responsible AI” with similar concepts.
###
2.1 What is Social Responsibility of AI?
######
Definition 1 (Social Responsibility of AI)
Social Responsibility of AI refers to a human value-driven process where values such as Fairness, Transparency, Accountability, Reliability and Safety, Privacy and Security, and Inclusiveness are the principles; designing Socially Responsible AI Algorithms is the means; and addressing the social expectations of generating shared value – enhancing both AI’s ability and benefits to society – is the main objective.
Here, we define three dimensions of Social Responsibility of AI: the principles lay the foundations for ethical AI systems; the means to reach the overarching goal of Social Responsibility of AI is to develop Socially Responsible AI Algorithms; and the objective of Social Responsibility of AI is to improve both AI’s capability and humanity with the second being the proactive goal.
###
2.2 The Pyramid of Social Responsibility of AI
Social Responsibility of AI should be framed in such a way that the entire range of AI responsibilities are embraced. Adapting Carroll’s Pyramid of CSR (?) in the AI context, we suggest four kinds of social responsibilities that constitute the Social Responsibility of AI: functional, legal, ethical, and philanthropic responsibilities, as shown in Figure [1](#S2.F1 "Figure 1 ‣ 2.2 The Pyramid of Social Responsibility of AI ‣ 2 Social Responsibility of AI ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"). By modularizing AI responsibilities, we hope to help AI technologists and researchers to reconcile these obligations and simultaneously fulfill all the components in the pyramid. All of these responsibilities have always existed, but functional responsibilities have been the main consideration until recently. Each type of responsibility requires close consideration.
Figure 1: The pyramid of Social Responsibility of AI, adapted from the Pyramid of CSR by ? (?).
The pyramid portrays the four components of Social Responsibility of AI, beginning with the basic building block notion that the functional competence of AI undergirds all else. Functional responsibilities require AI systems to perform in a manner consistent with profits maximization, operating efficiency, and other key performance indicators. Meanwhile, AI is expected to obey the law, which codifies the acceptable and unacceptable behaviors in our society. That is, legal responsibilities require AI systems to perform in a manner consistent with expectations of government and law. All AI systems should at least meet the minimal legal requirements. At its most fundamental level, ethical responsibilities are the obligation to do what is right, just, and fair, and to prevent or mitigate negative impact on stakeholders (e.g., users, the environment). To fulfill its ethical responsibilities, AI systems need to perform in a manner consistent with societal expectations and ethical norms, which cannot be compromised in order to achieve AI’s functional responsibilities. Finally, in philanthropic responsibilities, AI systems are expected to be good AI citizens and to contribute to tackling societal challenges such as cancer and climate change. Particularly, it is important for AI systems to perform in a manner consistent with the philanthropic and charitable expectations of society to enhance people’s quality of life. The distinguishing feature between ethical and philanthropic responsibilities is that the latter are not expected in an ethical sense. For example, while communities desire AI systems to be applied to humanitarian projects or purposes, they do not regard the AI systems as unethical if they do not provide such services. We explore the nature of Social Responsibility of AI by focusing on its components to help AI technologists to reconcile these obligations. Though these four components are depicted as separate concepts, they are not mutually exclusive. It is necessary for AI technologists and researchers to recognize that these obligations are in a constant but dynamic tension with one another.
###
2.3 Comparisons of Similar Concepts
Based on Definition 1 and the pyramid of socially responsibility of AI, we compare Socially Responsible AI with other similar concepts, as illustrated in Table [1](#S2.T1 "Table 1 ‣ 2.3 Comparisons of Similar Concepts ‣ 2 Social Responsibility of AI ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"). The results show that Socially Responsible AI holds a systematic view that subsumes existing concepts and further considers the fundamental responsibilities of AI systems – to be functional and legal, as well as their philanthropic responsibilities – to be able to improve life quality of well beings and address challenging societal issues. In the rest of this survey, we focus our discussions on the ethical (Section 3, essentials of SRAs) and philanthropic (Section 4, roles of SRAs) responsibilities of AI given that both the functional and legal responsibilities are the usual focuses in AI research and development. An overview of SRAs research is illustrated in Figure [2](#S3.F2 "Figure 2 ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"), which we will refer back to throughout the remainder of the survey. Importantly, in our view, the essentials of SRAs work toward ethical responsibilities, and their roles in society encompass both ethical and philanthropic responsibilities.
| Concepts | Definitions |
| --- | --- |
| Robust AI | AI systems with the ability “to cope with errors during execution and cope with erroneous input” (?). |
| Ethical AI | AI systems that do what is right, fair, and just. Prevent harm. |
| Trustworthy AI | AI systems that achieve their full potential if trust can be established in the development, deployment, and use (?). |
| Fair AI | AI systems absent from “any prejudice or favoritism toward an individual or a group based on their inherent or acquired characteristics” (?). |
| Safe AI | AI systems deployed in ways that do not harm humanity (?). |
| Dependable AI | AI systems that focus on reliability, verifiability, explainability, and security (?). |
| Human-centered AI | AI systems that are “continuously improving because of human input while providing an effective experience between human and robot”222https://www.cognizant.com/glossary/human-centered-ai. |
Table 1: Definitions of concepts similar to Socially Responsible AI.
3 Socially Responsible AI Algorithms (SRAs)
--------------------------------------------
The role of AI technologists and researchers carries a number of responsibilities. The most obvious is developing accurate, reliable, and trustworthy algorithms that can be depended on by their users. Yet, this has never been a trivial task. For example, due to the various types of human biases, e.g., confirmation bias, gender bias, and anchoring bias, AI technologists and researchers often inadvertently inject these same kinds of bias into the developed algorithms, especially when using machine learning techniques. For example, supervised machine learning is a common technique for learning and validating algorithms through manually annotated data, loss functions, and related evaluation metrics. Numerous uncertainties – e.g., imbalanced data, ill-defined criteria for data annotation, over-simplified loss functions, and unexplainable results – potentially lurk in this “beautiful” pipeline and will eventually lead to negative outcomes such as biases and discrimination. With the growing reliance on AI in almost any field in our society, we must bring upfront the vital question about how to develop Socially Responsible AI Algorithms. While conclusive answers are yet to be found, we attempt to provide a systematic framework of SRAs (illustrated in Figure [3](#S3.F3 "Figure 3 ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges")) to discuss the components of AI’s ethical responsibilities, the roles of SRAs in terms of AI’s philanthropic and ethical responsibilities, and the feedback from users routed back as inputs to SRAs. We hope to broaden future discussions on this subject. In this regard, we define SRAs as follows:
Figure 2: An overview of SRAs Research.
Figure 3: The framework of Socially Responsible AI Algorithms (SRAs). It consists of the essentials (i.e., the internal mechanisms) of SRAs (left), their roles (right), and feedback received from end users for helping SRAs gradually achieve the expected social values (bottom). The essentials of SRAs center on the ethical responsibilities of AI and the roles of SRAs require philanthropic responsibilities and ethical responsibilities.
######
Definition 2 (Socially Responsible AI Algorithms)
Socially Responsible AI Algorithms are the intelligent algorithms that prioritize the needs of all stakeholders as the highest priority, especially the minoritized and disadvantaged users, in order to make just and trustworthy decisions. These obligations include protecting and informing users; preventing and mitigating negative impact; and maximizing the long-term beneficial impact. Socially Responsible AI Algorithms constantly receive feedback from users to continually accomplish the expected social values.
In this definition, we highlight that the functional (e.g., maximizing profits) and societal (e.g., transparency) objectives are integral parts of AI algorithms. SRAs aim to be socially responsible while still meeting and exceeding business objectives.
###
3.1 Subjects of Socially Indifferent AI Algorithms
Every human being can be a potential victim of socially indifferent AI algorithms. Mirroring society, the ones who suffer the most, both in frequency and severity, are minorities and disadvantaged groups such as black, indigenous and people of color (BIPOC), and females. For example, Google mislabeled an image of two black people as “gorillas” (?) and more frequently showed ads of high-paying jobs to males than females (?). Similar gender bias was also found in Facebook algorithms behind the job ads (?). In domains with high-stakes decisions, e.g., financial services, healthcare, and criminal justice, it is not uncommon to identify instances where socially indifferent AI algorithms favor privileged groups. For example, the algorithm used in Correctional Offender Management Profiling for Alternative Sanctions (COMPAS) was found almost twice as likely to mislabel a black defendant as a future risk than a white defendant (?). Identifying the subjects of socially indifferent AI algorithms depends on the context. In another study, the journalistic organization ProPublica333https://www.propublica.org/ investigated algorithms that determine online prices for Princeton Review’s tutoring classes. The results showed that people who lived in higher income areas were charged twice as much as the general public and than people living in a zip code with high population density. Asians were 1.8 times more likely to pay higher price, regardless of their income (?). Analogously, these AI algorithms might put poor people who cannot afford internet service at disadvantage because they simply have never seen such data samples in the training process.
When it comes to purpose-driven collection and use of data, each individual can be the subject of socially indifferent AI algorithms. Users’ personal data are frequently collected and used without their consent. Such data includes granular details such as contact information, online browsing and session record, social media consumption, location and so on. While most of us are aware of our data being used, few have controls to where and how the data is used, and by whom. The misuse of data and lack of knowledge causes users to become the victims of privacy-leakage and distrust.
###
3.2 Causes of Socially Indifferent AI Algorithms
There are many potential factors that can cause AI algorithms to be socially indifferent. Here, we list several causes that have been frequently discussed in literature (?, ?). They are formalization, measuring errors, bias, privacy, and correlation versus causation.
####
3.2.1 Formalization
AI algorithms encompass data formalization, label formalization, formalization of loss function and evaluation metrics. We unconsciously make some frame of reference commitment to each of these formalizations. Firstly, the social and historical context are often left out when transforming raw data into numerical feature vectors. Therefore, AI algorithms are trained on pre-processed data with important contextual information missing. Secondly, data annotation can be problematic for a number of reasons. For example, what are the criteria? Who defines the criteria? Who are the annotators? How can it be ensured that they all follow the criteria? What we have for model training are only proxies of the true labels (?). Ill-formulated loss functions can also result in socially indifferent AI algorithms. Many loss functions in the tasks are over-simplified to solely focus on maximizing profits and minimizing losses. The concerns of unethical optimization are recently discussed by ? (?). Unknown to AI systems, certain strategies in the optimization space that are considered as unethical by stakeholder may be selected to satisfy the simplified task requirements. Lastly, the use of inappropriate benchmarks for evaluation may push algorithms away from the overarching goal of the task and fuel injustice.
####
3.2.2 Measuring Errors
Another cause of socially indifferent AI algorithms is the errors when measuring algorithm performance. When reporting results, researchers typically proclaim the proposed algorithms can achieve certain accuracy or F1 scores. However, this is based on assumptions that the training and test samples are representative of the target population and their distributions are similar enough. Yet, how often does the assumption hold in practice? As illustrated in Figure [4](#S3.F4 "Figure 4 ‣ 3.2.2 Measuring Errors ‣ 3.2 Causes of Socially Indifferent AI Algorithms ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"), with non-representative samples, the learned model can achieve zero training error and perform well on the testing data at the initial stage. However, with more data being tested later, the model performance deteriorates because the learned model does not represent the true model.
Figure 4: An example of measuring errors. The green line denotes the learned model and the blue one is the true model. ‘+’ and ‘-’ represent training data belonging to different classes; ‘X’ represents testing data. Image taken from Getoor’s slides for 2019 IEEE Big Data keynote (?) with permission.
####
3.2.3 Bias
Bias is one of the most discussed topics regarding responsible AI. We here focus on the data bias, automation bias, and algorithmic bias (?).
Data Bias.
Data, especially big data, is often heterogeneous – data with high variability of types and formats, e.g., text, image, and video. The availability of multiple data sources brings unprecedented opportunities as well as unequivocally presented challenges (?). For instance, high-dimensional data such as text is infamous for the danger of overfitting and the curse of dimensionality. Additionally, it is rather challenging to find subset of features that are predictive but uncorrelated. The required number samples for generalization also grows proportionally with feature dimension. One example is how the U.S. National Security Agency tried to use AI algorithms to identify potential terrorists. The Skynet project collected cellular network traffic in Pakistan and extracted 80 features for each cell phone user with only 7 known terrorists (?). The algorithm ended up identifying an Al Jazeera reporter covering Al Qaeda as a potential terrorist. Data heterogeneity is also against the well known i.i.d.formulae-sequence𝑖𝑖𝑑i.i.d.italic\_i . italic\_i . italic\_d . assumption in most learning algorithms (?). Therefore, training these algorithms on heterogeneous data can result in undesired results. Imbalanced subgroups is another source of data bias. As illustrated in (?), regression analysis based on the subgroups with balanced fitness level suggests positive correlation between BMI and daily pasta calorie intake whereas that based on less balanced data shows almost no relationship.
Automation Bias. This type of bias refers to our preference to results suggested by automated decision-making systems while ignoring the contradictory information. Too much reliance on the automated systems without sparing additional thoughts in making final decisions, we might end up abdicating decision responsibility to AI algorithms.
Algorithmic Bias. Algorithmic bias regards biases added purely by the algorithm itself (?). Some algorithms are inadvertently taught prejudices and unethical biases by societal patterns hidden in the data. Typically, models fit better to features that frequently appear in the data. For example, an automatic AI recruiting tool will learn to make decisions for a given applicant of a software engineer position using observed patterns such as “experience”, “programming skills”, “degree”, and “past projects”. For a position where gender disparity is large, the algorithms mistakenly interpret this collective imbalance as a useful pattern in the data rather than undesirable noise that should have been discarded. Algorithmic bias is systematic and repeatable error in an AI system that creates discriminated outcome, e.g., privileging wealthy users over others. It can amplify, operationalize, and even legitimize institutional bias (?).
####
3.2.4 Data Misuse
Data is the fuel and new currency that has empowered tremendous progress in AI research. Search engines have to rely on data to craft precisely personalized recommendation that improves the online experience of consumers, including online shopping, book recommendation, entertainment, and so on. However, users’ data are frequently misused without the consent and awareness of users. One example is the Facebook-Cambridge Analytical scandal (?) where millions of Facebook users’ personal data was collected by Cambridge Analytica (?), without their consent. In a more recent study (?), researchers show that Facebook allows advertisers to exploit its users’ sensitive information for tailored ad campaigns. To make things worse, users often have no clue about where, how, and why their data is being used, and by whom. The lack of knowledge and choice over their data causes users to undervalue their personal data, and further creates issues such as privacy and distrust.
####
3.2.5 Correlation vs Causation
Figure 5: Confounders are common reasons for spurious correlation between two variables that are not causally connected.
AI Algorithms can become socially indifferent when correlation is misinterpreted as causation. For example, in the diagram in Figure [5](#S3.F5 "Figure 5 ‣ 3.2.5 Correlation vs Causation ‣ 3.2 Causes of Socially Indifferent AI Algorithms ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"), we observe a strong correlation between the electric bill of an ice cream shop and ice cream sales. Apparently, high electric bill cannot cause the ice cream sales to increase. Rather, weather is the common cause of electric bill and the sale, i.e., high temperature causes high electric bill and the increased ice cream sales. Weather – the confounder – creates a spurious correlation between electric bill and ice cream sales. Causality is a generic relationship between the cause and the outcome (?). While correlation helps with prediction, causation is important for decision making. One typical example is Simpson’s Paradox (?). It describes a phenomenon where a trend or association observed in subgroups maybe opposite to that observed when these subgroups are aggregated. For instance, in the study of analyzing the sex bias in graduation admissions at UC Berkeley (?), the admission rate was found higher in male applicants when using the entire data. However, when the admission data were separated and analyzed over the departments, female candidates had equal or even higher admission rate over male candidates.
###
3.3 Objectives of Socially Responsible AI Algorithms
Essentially, the goal is to (re)build trust in AI. By definition, trust is the “firm belief in the reliability, truth or ability of someone or something”444Definition from Oxford Languages.. It is a high-level concept that needs to be specified by more concrete objectives. We here discuss the SRAs objectives that have been discussed comparatively frequently in literature. They are fairness, transparency, and safety as illustrated in Figure [6](#S3.F6 "Figure 6 ‣ 3.3.1 Fairness ‣ 3.3 Objectives of Socially Responsible AI Algorithms ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges").
####
3.3.1 Fairness
Fairness in AI has gained substantial attentions in both research and industry since 2010. For decades, researchers found it rather challenging to present a unified definition of fairness in part because fairness is a societal and ethical concept. This concept is mostly subjective, changes over social context, and evolves over time, making fairness a rather challenging goal to achieve in practice. Because SRAs is a decision-making process commensurate with social values, we here adopt a fairness definition in the context of decision-making:
######
Definition 3 (Fairness)
“Fairness is the absence of any prejudice or favoritism toward an individual or a group based on their inherent or acquired characteristics” (?).
Figure 6: The objectives of Socially Responsible AI Algorithms.
Note that even an ideally “fair” AI system defined in a specific context might still lead to biased decisions as the entire decision making process involves numerous elements such as policy makers and environment. While the concept of fairness is difficult to pin down, unfairness/bias/discrimination might be easier to identify. There are six types of discrimination (?). Direct discrimination results from protected attributes of individuals while indirect discrimination from seemingly neural and non-protected attributes. Systemic discrimination relates to policies that may show discrimination against subgroups of population. Statistical discrimination occurs when decision makers use average statistics to represent individuals. Depending whether the differences amongst different groups can be justified or not, we further have explainable and unexplainable discrimination.
####
3.3.2 Transparency
Transparency is another important but quite ambiguous concept. This is partly because AI alone can be defined in more than 70 ways (?). When we seek a transparent algorithm, we are asking for an understandable explanation of how it works (?): What does the training set look like? Who collected the data? What is the algorithm doing? There are mainly three types of transparency with regard to human interpretability of AI algorithms (?): For a developer, the goal of transparency is to understand how the algorithm works and get a sense of why; for a deployer who owns and releases the algorithm to the public, the goal of transparency is to make the consumers to feel safe and comfortable to use the system; and what transparency means to a user is understanding what the AI system is doing and why. We may further differentiate global transparency from local transparency, the former aims to explain the entire system whereas the latter explains a decision within a particular context.
Yet, at the same time, disclosures about AI can pose potential risks: explanations can be hacked and releasing additional information may make AI more vulnerable to attacks. It is becoming clear that transparency is often beneficial but not universally good (?). The AI “transparency paradox” encourages different parties of AI systems to think more carefully about how to balance the transparency and the risks it poses. We can also see related discussions in recent work such as (?). The paper studied how the widely recognized interpretable algorithms LIME (?) and SHAP (?) could be hacked. As the authors illustrated, explanations can be purposefully manipulated, leading to a loss of trust not only in the model but also in its explanations (?). Consequently, while working towards the goal of transparency, we must also recognize that privacy and security are the indispensable conditions we need to satisfy.
####
3.3.3 Safety
Because AI systems operate in a world with much uncertainty, volatility, and flux, another objective of SRAs is to be safe, accurate, and reliable (?). There are four operational objectives relevant to Safety: accuracy, reliability, security, and robustness (?). In machine learning, accuracy is typically measured by error rate or the fraction of instances for which the algorithm produces an incorrect output. As a standard performance metric, accuracy should be the fundamental component to establishing the approach to safe AI. It is necessary to specify a proper performance measure for evaluating any AI systems. For instance, when data for classification tasks is extremely imbalanced, precision, recall, and F1 scores are more appropriate than accuracy. The objective of reliability is to ensure that AI systems behave as we anticipate. It is a measure of consistency and is important to establish confidence in the safety of AI systems. Security encompasses the protection of information integrity, confidentiality, and continuous functionality to its users. Under harsh conditions (e.g., adversarial attack, perturbations, and implementation error), AI systems are expected to functions reliably and accurately, i.e., Robustness.
###
3.4 Means Towards Socially Responsible AI Algorithms
In this section, we review four primary machine learning techniques and statistical methods for achieving the goals of SRAs – interpretability and explainability, adversarial machine learning, causal learning, and uncertainty quantification. Existing surveys have conducted comprehensive reviews on each of these techniques: e.g., interpretablity (?, ?), causal learning (?, ?), adversarial machine learning (?, ?), and uncertainty quantification (?). We thereby focus on the basics and the most frequently discussed methods in each means.
####
3.4.1 Interpretability and Explainability
Interpretability and explanability are the keys to increasing transparency of AI algorithms. This is extremely important when we leverage these algorithms for high-stakes prediction applications, which deeply impact people’s lives (?). Existing work in machine learning interpretability can be categorized according to different criteria. Depending on when the interpretability methods are applicable (before, during, or after building the machine learning model), we have pre-model (before), in-model (during), and post-model (after) interpretability. Pre-model techniques are only applicable to the data itself. It requires an in-depth understanding of the data before building the model, e.g., sparsity and dimensionality. Therefore, it is closely related to data interpretability (?), in which classic descriptive statistics and data visualization methods are often used, including Principal Component Analysis (?) and t-SNE (?), and clustering methods such as k𝑘kitalic\_k-means (?). In-model interpretability asks for intrinsically interpretable AI algorithms (e.g., ?), we can also refer to it as intrinsic interpretability. It can be achieved through imposition of constraints on the model such as causality, sparsity, or physical conditions from domain knowledge (?). In-model interpretability answers question how the model works (?). Decision trees, rule-based models, linear regression, attention network, and disentangled representation learning are in-model interpretability techniques. Post-model interpretability, or post-hoc interpretability (e.g., ?, ?), is applied after model training. It answers the question what else can the model tell us (?). Post-model interpretability include local explanations (?), saliency maps (?), example-based explanations (?), influence functions (?), feature visualization (?), and explaining by base interpretable models (?).
Another criterion to group current interpretability techniques is model-specific vs model-agnostic. Model-specific interpretation is based on internals of a specific model (?). To illustrate, the coefficients of a linear regression model belong to model-specific interpretation. Model-agnostic methods do not have access to the model inner workings, rather, they are applied to any machine learning model after it has been trained. Essentially, the goal of interpretability is to help the user understand the decisions made by the machine learning models through the tool explanation. There are pragmatic and non-pragmatic theories of explanation. The former indicates that explanation should be a good answer that can be easily understood by the audience. The non-pragmatic theory emphasizes the correctness of the answer to the why-question. Both need to have the following properties (?): expressive power, translucency, portability, and algorithmic complexity.
####
3.4.2 Adversarial Machine Learning
Machine learning models, especially deep learning models, are vulnerable to crafted adversarial examples, which are imperceptible to human eyes but can easily fool deep neural networks (NN) in the testing/deploying stage (?). Adversarial examples have posed great concerns in the security and integrity of various applications. Adversarial machine learning, therefore, closely relates to the robustness of SRAs.
The security of any machine learning model is measured with regard to the adversarial goals and capabilities (?). Identifying the threat surface (?) of an AI system built on machine learning models is critical to understand where and how an adversary may subvert the system under attack. For example, the attack surface in a standard automated vehicle system can be defined with regard to the data processing pipeline. Typically, there are three types of attacks the attack surface can identify: evasion attack – the adversary attempts to evade the system by manipulating malicious samples during testing phase, poisoning attack – the adversary attempts to poison the training data by injecting carefully designed samples into the learning process, and exploratory attack – it tries to collect as much information as possible about the learning algorithm of the underlying system and pattern in training data. Depending on the amount of information available to an adversary about the system, we can define different types of adversarial capabilities. In the training phase (i.e., training phase capabilities), there are three broad attack strategies: (1) data injection. The adversary can only augment new data to the training set; (2) data modification. The adversary has full access to the training data; and (3) logic corruption. The adversary can modify the learning algorithm. In the testing phase (i.e., testing phase capabilities), adversarial attacks focus on producing incorrect outputs. For white-box attack, an adversary has full knowledge about the model used for prediction: algorithm used in training, training data distribution, and the parameters of the fully trained model. The other type of attack is black-box attack, which, on the contrary, assumes no knowledge about the model and only uses historical information or information about the settings. The primary goal of black-box attack is to train a local model with the data distribution, i.e., non-adaptive attack, and with carefully selected dataset by querying the target model, i.e., adaptive attack.
Exploratory attacks do not have access to the training data but aim to learn the current state by probing the learner. Commonly used techniques include model inversion attack (?, ?), model extraction using APIs (?), and inference attack (?, ?). The popular attacks are evasion attacks where malicious inputs are craftily manipulated so as to fool the model to make false predictions. Poisoning attacks, however, modify the input during the training phase to obtain the desired results. Some of the well-known techniques are generative adversarial network (GAN) (?), adversarial examples generation (including training phase modification, e.g., ?, and testing phase modification, e.g., ?), GAN-based attack in collaborative deep learning (?), and adversarial classification (?).
####
3.4.3 Causal Learning
Causal inference and reasoning is a critical ingredient for AI to achieve human-level intelligence, an overarching goal of Socially Responsible AI. The momentum of integrating causality into responsible AI is growing, as witnessed by a number of works (e.g., ?, ?, ?) studying SRAs through causal learning methods.
Basics of Causal Learning. The two fundamental frameworks in causal learning are structural causal models (?) and potential outcome (?). Structural causal models rely on the causal graph, which is a special class of Bayesian network with edges denoting causal relationships. A more structured format is referred to as structural equations. One of the fundamental notions in structural causal models is the do-calculus (?), an operation for intervention. The difficulty to conduct causal study is the difference between the observational and interventional distribution, the latter describes what the distribution of outcome Y𝑌Yitalic\_Y is if we were to set covariates X=x𝑋𝑥X=xitalic\_X = italic\_x. Potential outcome framework interprets causality as given the treatment and outcome, we can only observe one potential outcome. The counterfactuals – potential outcome that would have been observed if the individual had received a different treatment – however, can never be observed in reality. These two frameworks are the foundations of causal effect estimation (estimating effect of a treatment) and causal discovery (learning causal relations amongst different variables).
Many important concepts in causal inference have been adapted to AI such as intervention and counterfactual reasoning. Here, we introduce the causal concept most frequently used in SRAs – propensity score, defined as “conditional probability of assignment to a particular treatment given a vector of observed covariates” (?). A popular propensity-based approach is Inverse Probability of Treatment Weighting (?). To synthesize a randomized control trial (?), it uses covariate balancing to weigh instances based on their propensity scores and the probability of an instance to receive the treatment. Let tisubscript𝑡𝑖t\_{i}italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT and xisubscript𝑥𝑖x\_{i}italic\_x start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT be the treatment assignment and covariate of instance i𝑖iitalic\_i, the weight wisubscript𝑤𝑖w\_{i}italic\_w start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT is typically computed by the following formula:
| | | | |
| --- | --- | --- | --- |
| | wi=tiP(ti|xi)+1−ti1−P(ti|xi),subscript𝑤𝑖subscript𝑡𝑖𝑃conditionalsubscript𝑡𝑖subscript𝑥𝑖1subscript𝑡𝑖1𝑃conditionalsubscript𝑡𝑖subscript𝑥𝑖w\_{i}=\frac{t\_{i}}{P(t\_{i}|x\_{i})}+\frac{1-t\_{i}}{1-P(t\_{i}|x\_{i})},italic\_w start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT = divide start\_ARG italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT end\_ARG start\_ARG italic\_P ( italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT | italic\_x start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT ) end\_ARG + divide start\_ARG 1 - italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT end\_ARG start\_ARG 1 - italic\_P ( italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT | italic\_x start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT ) end\_ARG , | | (1) |
where P(ti|xi)𝑃conditionalsubscript𝑡𝑖subscript𝑥𝑖P(t\_{i}|x\_{i})italic\_P ( italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT | italic\_x start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT ) quantifies the propensity score. The weighted average of the observed outcomes for the treatment and control groups are defined as
| | | | |
| --- | --- | --- | --- |
| | τ^=1n1∑i:ti=1wiyi−1n0∑i:ti=0wiyi,^𝜏1subscript𝑛1subscript:𝑖subscript𝑡𝑖1subscript𝑤𝑖subscript𝑦𝑖1subscript𝑛0subscript:𝑖subscript𝑡𝑖0subscript𝑤𝑖subscript𝑦𝑖\hat{\tau}=\frac{1}{n\_{1}}\sum\_{i:t\_{i}=1}w\_{i}y\_{i}-\frac{1}{n\_{0}}\sum\_{i:t\_{i}=0}w\_{i}y\_{i},over^ start\_ARG italic\_τ end\_ARG = divide start\_ARG 1 end\_ARG start\_ARG italic\_n start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT end\_ARG ∑ start\_POSTSUBSCRIPT italic\_i : italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT = 1 end\_POSTSUBSCRIPT italic\_w start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT italic\_y start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT - divide start\_ARG 1 end\_ARG start\_ARG italic\_n start\_POSTSUBSCRIPT 0 end\_POSTSUBSCRIPT end\_ARG ∑ start\_POSTSUBSCRIPT italic\_i : italic\_t start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT = 0 end\_POSTSUBSCRIPT italic\_w start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT italic\_y start\_POSTSUBSCRIPT italic\_i end\_POSTSUBSCRIPT , | | (2) |
where n1subscript𝑛1n\_{1}italic\_n start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT and n0subscript𝑛0n\_{0}italic\_n start\_POSTSUBSCRIPT 0 end\_POSTSUBSCRIPT denote the sizes of the treated and controlled groups.
Causal Learning for SRAs. Firstly, it is becoming increasingly popular to use causal models to solve fairness-related issues. For example, the subject of causality and its importance to address fairness issue was discussed in (?). Causal models can also be used to discover and eliminate discrimination to make decisions that are irrespective of sensitive attributes, on individual-, group-, and system-level, see, e.g., (?, ?, ?). Secondly, bias alleviation is another field where causal learning methods are frequently discussed and affect many machine learning applications at large. The emerging research on debiasing recommender system (?, ?, ?) can serve as one example. Due to the biased nature of user behavior data, recommender systems inevitably involve with various discrimination-related issues: recommending less career coaching services and high-paying jobs to women (?, ?), recommending more male-authored books (?), and minorities are less likely to become social influencers (?, ?). Gender and ethnic biases were even found in a broader context, e.g., word embeddings trained on 100 years of text data (?). Causal approaches such as (?) aim to mitigate such bias in word embedding relations.
Thirdly, causal learning methods also have had discernible achievements in transparency, especially the interpretability of black-box algorithms. Causality is particularly desired since these algorithms only capture correlations not real causes (?). Further, it has been suggested that counterfactual explanations are the highest level of interpretability (?). For model-based interpretations, causal interpretability aims to explain the causal effect of a model component on the final decision (?, ?, ?). One example to differentiate it from traditional interpretability is only causal interpretability is able to answer question such as “What is the effect of the n𝑛nitalic\_n-th filter of the m𝑚mitalic\_m-th layer of a neural network on the prediction of the model?”. Counterfactual explanations is a type of example-based explanations, in which we look for data instances that can explain the underlying data distributions. Counterfactual explanations are human friendly, however, it is possible to have different true versions of explanations for the predicted results, i.e., the Rashomon effect (?). Studies such as (?, ?, ?) are proposed to address this issue. For detailed discussion on causal interpretability, please refer to (?). Lastly, causal learning is inherently related to the robustness or adaptability of AI systems, which have been noted to lack the capability of reacting to new circumstances they are not trained for. Causal relationship, however, is expected to be invariant and robust across environments (?, ?). This complements intensive earlier efforts toward “transfer learning”, “domain adaptation”, and “lifelong learning” (?). Some current work seeking to extrapolate the relationship between AI robustness and causality includes the independent causal mechanism principle (?, ?), invariant prediction (?), and disentangled causal mechanism (?, ?).
####
3.4.4 Uncertainty Quantification
AI research continues to develop new state-of-the-art algorithms with superior performance and large-scaled datasets with high quality. Even using the best models and training data, it is still infeasible for AI systems to cover all the potential situations when deployed into real-world applications. As a matter of fact, AI systems always encounter new samples that are different from those used for training. The core question is how to leverage the strengths of these uncertainties. Recent research, e.g., (?), has advocated to measure, communicate, and use uncertainty as a form of transparency. There are also tools such as IBM’s Uncertainty Quantification 360555http://uq360.mybluemix.net/overview to provide AI practitioners access to related resources as common practices for AI transparency. Consequently, uncertainty quantification plays a crucial role in the optimization and decision-making process in SRAs.
There are typically two kinds of uncertainties in risk analysis processes: first, the aleatory uncertainty describes the inherent randomness of systems. For example, an AI system can present different results even with the same set of inputs. The uncertainty arises from underlying random variations within the data. Second, the epistemic uncertainty represents the effect of an unknown phenomenon or an internal parameter. The primary reason leading to this type of uncertainty is the lack of observed data. As the variation among the data in aleatory uncertainty is often observable, we can well quantify the uncertainty and assess the risks. Quantification of epistemic uncertainty is more challenging because AI systems are forced to extrapolate over unseen situations (?). In the literature of uncertainty quantification, one of the most widely recognized techniques are prediction intervals (PI). For neural-network-based models, PI can be categorized into multi-step PI construction methods (e.g., Bayesian method) and direct PI construction methods (e.g., lower upper bound estimation). Here, we briefly discuss several methods in each category. Please refer to the survey (?) for more details.
Multi-Step Prediction Intervals Construction Methods. Delta method, Bayesian method, Mean-Variance Estimation method, and Bootstrap method are the four conventional multi-step methods reported in literature. Delta method constructs PIs through nonlinear regression using Tylor series expansion. Particularly, we linearize neural network models through optimization by minimizing the error-based loss function, sum square error. Under the assumption that uncertainty is from normal and homogeneous distribution, we then employ standard asymptotic theory to construct PIs. Delta method has been used in numerous case studies, e.g., (?, ?). Bayesian learning provides a natural framework for constructing PIs (?, ?) as it optimizes the posterior distribution of parameters from the assumed prior distribution. Despite its high generalization power, Bayesian techniques are limited by large computational complexity due to the calculation of Hessian matrix. Bootstrap method is the most popular among the four conventional multi-step PI construction methods (?, ?, ?). It includes smooth, parametric, wild, pairs, residual, Gaussian process, and other types of bootstrap techniques. In NN-based pairs bootstrap algorithm, for example, the key is to generate bootstrapped pairs by uniform sampling with replacement from the original training data. The estimation is then conducted for a single bootstrapped dataset (?).
Figure 7: Illustration of what Socially Responsible AI Algorithms (SRAs) can do. It requires philanthropic responsibilities and ethical responsibilities.
Direct Prediction Intervals Construction Methods. This category of methods can tackle some of the limitations in previous methods, such as high demanding in computational power and stringent assumptions. When NN models are constructed through direct training without any assumptions, they can provide more adaptive and smarter PIs for any distribution of targets (?). Lower Upper Bound estimation method is such a technique that can be applied to arbitrary distribution of targets with more than one order reduced computation time. It directly calculates the lower and the upper bounds through trained NNs. Initially, Lower Upper Bound estimation NNs are optimized with the coverage width-based criterion, which presents several limitations. With all the benefits of the original Lower Upper Bound estimation method, the NN-based Direct Interval Forecasting method (?) has much shorter computation time and narrower PIs credited to the improved cost function and the reduced average coverage error. Other approaches for improving the cost function of Lower Upper Bound estimation include the normalized root-mean-square width and particle swarm optimization (?), optimal system by (?), the independent width and penalty factors (?), the deviation from mid-interval consideration (?), and the deviation information-based criterion (?).
4 Roles of SRAs
----------------
So far, we have introduced the essentials of SRAs to achieve the expected ethical responsibilities. But pragmatic questions regarding their intended use remain: How to operationalize SRAs? What can SRAs eventually do for societal well-being to address societal challenges? Both ethical and philanthropic responsibilities are indispensable ingredients of the answers. While the ultimate goal of SRAs is to do good and be a good AI citizen, their ethical responsibilities should be ensured first. When AI fails to fulfill its ethical responsibilities, its philanthropic benefits can be insignificant. For instance, despite the immense public good of COVID-19 vaccines, there has been great controversy about algorithms for their distribution, which have been shown to be inequitable (?). Some argue that distribution algorithms should prioritize saving more lives and bringing the economy back more rapidly (?); they support such an ‘unfair’ allocation, but we would argue that that is not unfairness, but simply a difference of values and ethics. In our view, roles of SRAs are expected to encompass both ethical and philanthropic responsibilities. In this survey, we describe three dimensions that SRAs can help with to improve the quality of human life as illustrated in Figure [7](#S3.F7 "Figure 7 ‣ 3.4.4 Uncertainty Quantification ‣ 3.4 Means Towards Socially Responsible AI Algorithms ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"): Protect (e.g., protect users’ personal information), Inform (e.g., fake news early detection), and Prevent/Mitigate (e.g., cyberbullying mitigation). We illustrate each dimension with research findings in several emerging societal issues. Particularly, for protecting dimension, we focus on privacy preserving and data dignity; for informing and preventing/mitigating dimensions, we discuss three societal issues that raise growing concerns recently: disinformation, abusive language, and unwanted bias. Because there are many various forms of abusive language such as hate speech and profanity, and the body of work related to each form is vast and diverse, spanning multiple interconnected disciplines, this survey uses the form of cyberbullying as a representative for the illustrations.
###
4.1 Protecting
The protecting dimension aims to cover or shield humans (especially the most vulnerable or at-risk) from harm, injury, and negative impact of AI systems, in order to intervene. This can be the protection of users’ personal data and their interactions with AI systems. Two typical examples are privacy preserving and data dignity.
####
4.1.1 Privacy-Preserving
The capability of deep learning models has been greatly improved by the emerging powerful infrastructures such as clouds and collaborative learning for model training. The fuel of this power, however, comes from data, particularly sensitive data. This has raised growing privacy concerns such as illegitimate use of private data and the disclosure of sensitive data (?, ?). Existing threats against privacy are typically from attacks such as the adversarial examples we discussed in Sec. [3.4.2](#S3.SS4.SSS2 "3.4.2 Adversarial Machine Learning ‣ 3.4 Means Towards Socially Responsible AI Algorithms ‣ 3 Socially Responsible AI Algorithms (SRAs) ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"). Specifically, there are direct information exposure (e.g., untrusted clouds), which is caused by direct intentional or unintentional data breaches, and indirect (inferred) information exposure (e.g., parameter inference), which is caused by direct access to the model or output. Existing privacy-preserving mechanisms can be classified into three categories, namely, private data aggregation methods, private training, and private inference (?).
Data aggregation methods are either context-free or context-aware. A context-free approach such as differential privacy (?), is unaware of the context or what the data will be used for. Context-aware approach such as information-theoretic privacy (?), on the other hand, is aware of the context in which the data will be used. A naïve technique for privacy protection is to remove identifiers from data, such as name, address, and zip code. It has been used for protecting patients’ information while processing their medical records, but the results are unsatisfying (?, ?, ?). The k-Anonymity method can prevent information from re-identification by showing at least k𝑘kitalic\_k samples with exact same set of attributes for given combination of attributes that the adversary has access to (?). The most commonly used data aggregation method is differential privacy, which aims to estimate the effect of removing an individual from the dataset and keep the effect of the inclusion of one’s data small. Some notable work includes the Laplace mechanism (?), differential privacy with Advanced Composition (?), and local differential privacy (?, ?).
Information-theoretic privacy is a context-aware approach that explicitly models the dataset statistics. By contrast, context-free methods assume worse-case dataset statistics and adversaries. This line of research was studied by ? (?), ? (?), and ? (?). The second type of privacy-preserving mechanism works during the training phase. Established work in private training is mostly used to guarantee differential privacy or semantic security and encryption (?). The two most common methods for encryption are homomorphic encryption (?) and secure multi-party computation (?). The third type of privacy-preserving mechanism works during the inference phase. It aims at the trained systems that are deployed to offer inference-as-a-service (?). Most methods in private inference are similar to those in private training, except for the information-theoretic privacy (?, ?, ?). It is typically used to offer information-theoretic mathematical or empirical evidence of how these methods operate to improve privacy. There is also work using differential privacy (?), homomorphic encryption (?, ?), and secure multi-party computation (?).
####
4.1.2 Data Dignity
Beyond privacy preserving, what is more urgent to accomplish is data dignity. It allows users to have absolute control to how their data is being used and they are paid accordingly (?). Data dignity encompasses the following aspects (?):
* •
To help users objectively determine the benefits and risks associated with their digital presence and personal data.
* •
To let users control how their data will be used and the purpose of using the data.
* •
To allow users to negotiate the terms of using their data.
* •
To give users complete right and autonomy to be found, analyzed, or forgotten, apart from the fundamental right over their data.
There are business models such as the Microsoft Data Bank designed to give users the control of their data and those shared by the Art of Research (?) about how people can buy and sell their personal data.
###
4.2 Informing
The informing dimension aims to deliver the facts or information to users, particularly the potential negative results, in a timely way. We illustrate it with a focus on the discussions of detecting disinformation, cyberbullying, and bias.
####
4.2.1 Disinformation Detection
Disinformation is false information that is deliberately created and spread to deceive people, a social group, organization, or country (?). The online information ecosystem is never short of disinformation and misinformation, and the growing concerns have been raised recently. Tackling disinformation is rather challenging mainly because (1) disinformation exists almost in all domains; (2) it is ever-changing with new problems, challenges, and threats emerging every day; (3) it entails the joint efforts
of interdisciplinary research – computer science, social science, politics, policy making, and psychology, cognitive science (?). Accurate and efficient identification of disinformation is the core to combat disinformation. Existing prominent approaches for disinformation detection primarily rely on news content, social context, user comments, fact-checking tools, and explainable and cross-domain detection.
Early work on disinformation detection has been focused on hand-crafted features extracted from text, such as lexical and syntactic features (?, ?). Apart from text, online platforms also provide abundant social information that can be leveraged to enrich the textual features, e.g., number of re-tweets and likes on Twitter. Informed by theories in social science and network science, another line of work exploits social network information to improve the detection performance. Common features are social context (?), user profile (?), user engagement (?), and relationships among news articles, readers, and publishers (?). A unique function of online platforms is that they allow users to interact through comments. Recent work has shown that user comments can provide weak supervision signal for identifying the authenticity of news articles, which enables early detection of disinformation (?). When the user comments are unavailable, it is possible to learn users’ response to news articles and then generate user responses (?). Fact-checking can be achieved manually or automatically. Manual fact-checking relies on domain experts or crowdsourced knowledge from users. Automatic fact-checking uses structure knowledge bases such as knowledge graph to verify the authenticity of news articles, see, e.g., (?). Beyond within-domain detection, other tasks such as cross-domain detection (?), explanation (?), and causal understanding of fake news dissemination (?) have also been discussed in literature.
####
4.2.2 Cyberbullying Detection
Cyberbullying differs from other forms of abusive language in that it is not an one-off incident but “aggressively intentional acts carried out by a group or an individual using electronic forms of contact, repeatedly or over time against victims who cannot easily defend themselves” (?). The increasingly reported number of cyberbullying cases on social media and the resulting detrimental impact have raised great concerns in society. Cyberbullying detection is regularly figured as a binary classification problem. While it shares some similarities with document classification, it should be noted that cyberbullying identification is inherently more complicated than simply identifying oppressive content (?).
Distinct characteristics of cyberbullying such as power imbalance and repetition of aggressive acts are central to marking a message or a social media session (?) as cyberbullying. Several major challenges in cyberbullying detection have been discussed in literature such as the formulation of the unique bullying characteristics, e.g., repetition, data annotation, and severe class imbalance. Depending on the employed features, established work can be classified into four categories: content-based, sentiment-based, user-based, and network-based methods. Features extracted from social media content are lexical items such as keywords, Bag of Words, pronoun and punctuation. Empirical evaluations have shown that textual features are the most informative predictors for cyberbullying detection (?). For instance, using number of offensive terms as content features is effective in detecting offensive and cursing behavior (?, ?, ?); Computing content similarity between tweets from different users can help capture users’ personality traits and peer influence, two important factors of cyberbullying occurrences (?). Sentiment-based features typically include key-words, phrases and emojis, and they are often combined with content-based features (?). A notable work (?) identified seven types of emotions in tweets such as anger, empathy, and fear. User-based features are typical characteristics of users, e.g., personality (e.g., hostility), demographics (e.g., age), and user activity (e.g., active users (?)). Hostility and neuroticism are found to be strongly related to cyberbullying behavior (?, ?). Further, gender and age are indicative of cyberbullying in certain cases (?). Network-based features measure the sociability of online users, e.g., number of friends, followers, and network embeddedness (?, ?). In addition, a number of methods seek to capture the temporal dynamics to characterize the repetition of cyberbullying, such as (?, ?, ?, ?).
####
4.2.3 Bias Detection
Compared to the well-defined notions of fairness, bias detection is much less studied and the solution is not as straightforward as it may seem (?). The challenges arise from various perspectives. First, the data and algorithms used to make a decision are often not available to policy makers or enforcement agents. Second, algorithms are becoming increasingly complex and the uninterpretability limits an investigator’s ability to identify systematic discrimination through analysis of algorithms. Rather, they have to examine the output from algorithms to check for anomalous results, increasing the difficulty and uncertainty of the task.
Data exploratory analysis is a simple but effective tool to detect data bias. In this initial step of data analysis, we can use basic data statistics and visual exploration to understand what is in a dataset and the characteristics of the data. For algorithmic bias, one of the earliest methods is to compare the selection rate of different groups. Discrimination is highly possible if the selection rate for one group is sufficiently lower than that for other groups. For example, the US Equal Employment Opportunity Commission (EEOC) advocates the “four-fifths rule” or “80% rule” (?) to identify a disparate impact. Suppose Y𝑌Yitalic\_Y denotes a binary class (e.g., hire or not), A𝐴Aitalic\_A is the protected attribute (e.g., gender), a dataset presents disparate impact if
| | | | |
| --- | --- | --- | --- |
| | Pr(Y=1|A=0)Pr(Y=1|A=1)≤τ=0.8.𝑃𝑟𝑌conditional1𝐴0𝑃𝑟𝑌conditional1𝐴1𝜏0.8\frac{Pr(Y=1|A=0)}{Pr(Y=1|A=1)}\leq\tau=0.8.divide start\_ARG italic\_P italic\_r ( italic\_Y = 1 | italic\_A = 0 ) end\_ARG start\_ARG italic\_P italic\_r ( italic\_Y = 1 | italic\_A = 1 ) end\_ARG ≤ italic\_τ = 0.8 . | | (3) |
However, statistical disparity does not necessarily indicate discrimination. If one group has disproportionately more qualified members, we may expect the differences between groups in the results.
A more frequently used approach is regression analysis (?), which is performed to examine the likelihood of favorable (or adverse) decisions across groups based on sensitive attributes. A significant, non-zero coefficient of the sensitive attributes given a correctly specified regression signals the presence of discrimination. However, we cannot guarantee to observe all the factors the decision maker considers. Therefore, instead of using rate at which decisions are made (e.g., the loan approval rates), bias detection can be based on the success rate of the decisions (e.g., the payback rate of the approved applicants (?)), i.e., the outcome test. Another less popular statistical approach for bias detection is benchmarking. The major challenge of benchmarking analysis is identifying the distribution of the sensitive attributes of the benchmark population where sensitive attributes are unlikely to influence the identification of being at-risk. Some solutions can be seen in (?, ?). Recently, AI researchers have developed tools to automatically detect bias. For instance, drawing on techniques in natural language processing and moral foundation theories, the tool by ? (?) can understand structure and nuances of content consistently showing up on left-leaning and right-leaning news sites, aiming to help consumers better prepare for unfamiliar news source. In earlier efforts, an international research group launched a non-profit organization Project Implicit666https://implicit.harvard.edu/implicit in 1998 aimed at detecting implicit social bias.
###
4.3 Preventing/Mitigating
If both of the first two dimensions fail, we may rely on the last dimension to prevent/mitigate the negative impact of socially indifferent AI algorithms on the end-users. We continue the discussions about disinformation, cyberbullying, and bias, with a focus on the prevention and mitigation strategies.
####
4.3.1 Disinformation Prevention/Mitigation
Preventing the generation/spread of disinformation and mitigating its negative impact is an urgent task because disinformation typically spread faster (?) than normal information due to the catchy news content and the ranking algorithms operating behind the online news platforms. To increase user engagement, social recommender systems are designed to recommend popular posts and trending content. Therefore, disinformation often gains more visibility. An effective approach for disinformation mitigation is to govern this visibility of news, e.g., recommendation and ranking based algorithms. Mitigation also relates to early detection.
Network intervention can slow down the spread of disinformation by influencing the exposed users in a social network. For example, we can launch a counter-cascade that consists of fact-checked version of false news articles. This is commonly referred to as the influence limitation or minimization problem (?). Given a network with accessible counter-cascade, the goal is to find a (minimum) set of nodes in this network such that the effect of the original cascade can be minimized. A variety of approximation algorithms (?, ?) have been proposed to solve the NP-hard problem and the variants. When applied to disinformation mitigation, they seek to inoculate as many nodes as possible in a short period of time. It is possible to extend the two cascades into tasks with multiple cascades, where we can further consider the different priorities of these cascades, i.e., each cascade influences the node in the network differently (?). The second method for disinformation mitigation is content flagging: social media platforms allow users to ‘flag’ or ‘report’ a news content if they find it offensive, harmful, and/or false. Big social media companies such as Facebook hired professional moderators to manually investigate and/or remove these content. However, considering the millions of news generated/spread every minute (?), it is impractical for these moderators to manually review all the news. The solution comes to the crowd wisdom – users can choose to ‘flag’ the content if it violates the community guidelines of the platform. Some platforms can further provide feedback for these users about if their fact-check is correct or not. User behavior is an effective predictor for disinformation detection (?), therefore, the third prevention method leverages the differences between user behaviors to identify susceptible or gullible users. For example, it is shown in (?) that groups of vulnerable Twitter users can be identified in fake news consumption. Other studies (?) also suggest that older people are more likely to spread disinformation.
####
4.3.2 Cyberbullying Prevention/Mitigation
In contrast to the large amount of work in cyberbullying detection, efforts for its prevention and mitigation have been a few. Some research suggests that prevention/mitigation strategies are defined at different levels (?). At technological level, we can consider providing parental control service, firewall blocking service, online services rules, text-message control, and mobile parental control, e.g., KnowBullying and BullyBlocker (?). Another effective tool is psychological approach, such as talking and listening to cyber-victims, providing counseling services, encouraging victims to make new relations and join social clubs. At education level, we are responsible to educate end-users, help improve their technical and cognitive skills. At administrative level, it is important for organizations and government to develop policies to regulate using free service and enhance workplace environment. Therefore, the goal of cyberbullying prevention/mitigation can only be accomplished with interdisciplinary collaborations, e.g., psychology, public health, computer science, and other behavioral and social sciences (?). One example is that computer and social scientists attempted to understand behavior of users in realistic environments by designing social media site for experimentation such as controlled study and post-study survey (?, ?).
Existing solutions to preventing cyberbullying can report/control/warn about message content (e.g., ?, ?), provide support for victims (e.g., ?), and educate both victims and bullies (e.g., ?). A variety of anti-bully apps are also available to promote well-being of users. For example, NoMoreBullyingMe App provides online meditation techniques to support victims; “Honestly” App (?) encourages users to share positive responses with each other (e.g., sing a song). However, current cyberbullying prevention strategies often do not work as desired because of the complexity and nuance with which adolescents bully others online (?).
####
4.3.3 Bias Mitigation
Prior approaches for bias mitigation focus on either designing fair machine learning algorithms or theorizing on the social and ethical aspects of machine learning discrimination (?). From the technical aspect, approaches to fairness typically can be categorized into pre-processing (prior to modelling), in-processing (at the point of modelling), and post-processing (after modelling). One condition to use pre-processing approaches is that the algorithm is allowed to modify the training data (?). We can then transform the data to remove the discrimination (?). In-processing approaches eliminate bias by modifying algorithms during the training process (?). We can either incorporate fairness notion into the objective function or impose fairness constraint (?, ?). When neither training data nor model can be modified, we can use post-processing approaches to reassign the predicted labels based on a defined function and a holdout set which was not used in the model training phase (?, ?). Most of these approaches are built on the notion of protected or sensitive variables that define the (un)privileged groups. Commonly used protected variables are age, gender, marital status, race, and disabilities. A shared characteristic of these groups is they are disproportionately (less) more likely to be positively classified. Fairness measures are important to quantify fairness in the development of fairness approaches. However, creating generalized notions of fairness quantification is a challenging task (?). Depending on the protected target, fairness metrics are usually designed for individual fairness (e.g., every one is treated equally), group fairness (e.g., different groups such as women vs men are treated equally), or subgroup fairness. Drawing on theories in causal inference, individual fairness also includes counterfactual fairness which describes that a decision is fair towards an individual if the result was same when s/he had taken a different sensitive attribute (?).
Recent years have witnessed immense progress of fair machine learning – a variety of methods have been proposed to address bias and discrimination over different applications. We focus on two mainstream methods: fair classification and fair regression. A review of machine learning fairness can be referred to (?, ?).
(1) Fair Classification. For a (binary) classifier with sensitive variable S𝑆Sitalic\_S, the target variable Y𝑌Yitalic\_Y, and the classification score R𝑅Ritalic\_R, general fairness desiderata have three “non-discrimination” criteria: Independence, i.e., R𝑅Ritalic\_RS;𝑆𝑒𝑝𝑎𝑟𝑎𝑡𝑖𝑜𝑛,i.e.,;\textit{Separation},i.e.,; Separation , italic\_i . italic\_e . ,R
⊧models\models⊧
S—Y;and𝑆𝑢𝑓𝑓𝑖𝑐𝑖𝑒𝑛𝑐𝑦,i.e.,;and\textit{Sufficiency},i.e.,; italic\_a italic\_n italic\_d Sufficiency , italic\_i . italic\_e . ,Y
⊧models\models⊧
S — R.Fairmachinelearningalgorithmsneedtoadopt/createspecificfairnessdefinitionsthatfitintocontext(?,?,?,?,?).Commonmethodsinfairclassificationincludeblinding(?,?),causalmethods(?,?),transformation(?,?,?),samplingandsubgroupanalysis(?,?),adversariallearning(?,?,?),reweighing(?,?),andregularizationandconstraintoptimization(?,?,?).(2) Fair Regression.Thegoaloffairregressionistojointlyminimizethedifferencebetweentrueandpredictedvaluesandensurefairness.Itfollowsthegeneralformulationoffairclassificationbutwithcontinuousratherthanbinary/categoricaltargetvariable.Accordingly,thefairnessdefinition,metrics,andthebasicalgorithmsareadaptedfromclassificationtoregression.Forexample,itissuggestedusingstatisticalparityandbounded−group−lossmetricstomeasurefairnessinregression(?).BiasinlinearregressionisconsideredastheeffectsofasensitiveattributeonthetargetvariablethroughthemeandifferencebetweengroupsandAUCmetrics(?).Onecommonlyusedapproachinfairregressionisregularization,e.g.,(?,?).Apartfromfairmachinelearning,algorithmoperatorsareencouragedtoshareenoughdetailsabouthowresearchiscarriedouttoallowotherstoreplicateit.Thisisaleapformitigatingbiasasithelpsend−userswithdifferenttechnicalbackgroundtounderstandhowthealgorithmworksbeforemakinganydecision.ItisalsosuggestedthatAItechnologistsandresearchersdevelopabiasimpactstatementasaself−regulatorypractice.Itcanhelpprobeandavertanypotentialbiasesthatareinjectedintoorresultantfromalgorithmicdecision(?).Someexamplequestionsinthestatementare``Whatwilltheautomateddecisiondo?′′,``Howwillpotentialbiasbedetected?′′,and``Whataretheoperatorincentives′′.Inalgorithmdesign,researchersarealsoresponsibletoencouragetheroleofdiversitywithintheteam,trainingdata,andthelevelofculturalsensitivity.The``diversity−in−design′′mechanismaimstotakedeliberateandtransparentactionstoaddresstheupfrontculturalbiasesandstereotypes.Furthermore,wemightalsoconsiderupdatingnondiscriminationandothercivilrightslawstointerpretandredressonlinedisparateimpacts(?).Anexampleofsuchconsiderationistounambiguouslydefinethethresholdsandparametersforthedisparatetreatmentsofprotectedgroupsbeforethealgorithmdesign..Fairmachinelearningalgorithmsneedtoadopt/createspecificfairnessdefinitionsthatfitintocontext\immediate({}?{,\ }?{,\ }?{,\ }?{,\ }?{\ignorespaces}).Commonmethodsinfairclassificationincludeblinding\immediate({}?{,\ }?{\ignorespaces}),causalmethods\immediate({}?{,\ }?{\ignorespaces}),transformation\immediate({}?{,\ }?{,\ }?{\ignorespaces}),samplingandsubgroupanalysis\immediate({}?{,\ }?{\ignorespaces}),adversariallearning\immediate({}?{,\ }?{,\ }?{\ignorespaces}),reweighing\immediate({}?{,\ }?{\ignorespaces}),andregularizationandconstraintoptimization\immediate({}?{,\ }?{,\ }?{\ignorespaces}).\par\noindent\textit{(2) Fair Regression.}Thegoaloffairregressionistojointlyminimizethedifferencebetweentrueandpredictedvaluesandensurefairness.Itfollowsthegeneralformulationoffairclassificationbutwithcontinuousratherthanbinary/categoricaltargetvariable.Accordingly,thefairnessdefinition,metrics,andthebasicalgorithmsareadaptedfromclassificationtoregression.Forexample,itissuggestedusingstatisticalparityandbounded-group-lossmetricstomeasurefairnessinregression\immediate({}?{\ignorespaces}).BiasinlinearregressionisconsideredastheeffectsofasensitiveattributeonthetargetvariablethroughthemeandifferencebetweengroupsandAUCmetrics\immediate({}?{\ignorespaces}).Onecommonlyusedapproachinfairregressionisregularization,e.g.,\immediate({}?{,\ }?{\ignorespaces}).\par Apartfromfairmachinelearning,algorithmoperatorsareencouragedtoshareenoughdetailsabouthowresearchiscarriedouttoallowotherstoreplicateit.Thisisaleapformitigatingbiasasithelpsend-userswithdifferenttechnicalbackgroundtounderstandhowthealgorithmworksbeforemakinganydecision.ItisalsosuggestedthatAItechnologistsandresearchersdevelopabiasimpactstatementasaself-regulatorypractice.Itcanhelpprobeandavertanypotentialbiasesthatareinjectedintoorresultantfromalgorithmicdecision\immediate({}?{\ignorespaces}).Someexamplequestionsinthestatementare``Whatwilltheautomateddecisiondo?^{\prime\prime},``Howwillpotentialbiasbedetected?^{\prime\prime},and``Whataretheoperatorincentives^{\prime\prime}.Inalgorithmdesign,researchersarealsoresponsibletoencouragetheroleofdiversitywithintheteam,trainingdata,andthelevelofculturalsensitivity.The``diversity-in-design^{\prime\prime}mechanismaimstotakedeliberateandtransparentactionstoaddresstheupfrontculturalbiasesandstereotypes.Furthermore,wemightalsoconsiderupdatingnondiscriminationandothercivilrightslawstointerpretandredressonlinedisparateimpacts\immediate({}?{\ignorespaces}).Anexampleofsuchconsiderationistounambiguouslydefinethethresholdsandparametersforthedisparatetreatmentsofprotectedgroupsbeforethealgorithmdesign.. italic\_F italic\_a italic\_i italic\_r italic\_m italic\_a italic\_c italic\_h italic\_i italic\_n italic\_e italic\_l italic\_e italic\_a italic\_r italic\_n italic\_i italic\_n italic\_g italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_s italic\_n italic\_e italic\_e italic\_d italic\_t italic\_o italic\_a italic\_d italic\_o italic\_p italic\_t / italic\_c italic\_r italic\_e italic\_a italic\_t italic\_e italic\_s italic\_p italic\_e italic\_c italic\_i italic\_f italic\_i italic\_c italic\_f italic\_a italic\_i italic\_r italic\_n italic\_e italic\_s italic\_s italic\_d italic\_e italic\_f italic\_i italic\_n italic\_i italic\_t italic\_i italic\_o italic\_n italic\_s italic\_t italic\_h italic\_a italic\_t italic\_f italic\_i italic\_t italic\_i italic\_n italic\_t italic\_o italic\_c italic\_o italic\_n italic\_t italic\_e italic\_x italic\_t ( ? , ? , ? , ? , ? ) . italic\_C italic\_o italic\_m italic\_m italic\_o italic\_n italic\_m italic\_e italic\_t italic\_h italic\_o italic\_d italic\_s italic\_i italic\_n italic\_f italic\_a italic\_i italic\_r italic\_c italic\_l italic\_a italic\_s italic\_s italic\_i italic\_f italic\_i italic\_c italic\_a italic\_t italic\_i italic\_o italic\_n italic\_i italic\_n italic\_c italic\_l italic\_u italic\_d italic\_e italic\_b italic\_l italic\_i italic\_n italic\_d italic\_i italic\_n italic\_g ( ? , ? ) , italic\_c italic\_a italic\_u italic\_s italic\_a italic\_l italic\_m italic\_e italic\_t italic\_h italic\_o italic\_d italic\_s ( ? , ? ) , italic\_t italic\_r italic\_a italic\_n italic\_s italic\_f italic\_o italic\_r italic\_m italic\_a italic\_t italic\_i italic\_o italic\_n ( ? , ? , ? ) , italic\_s italic\_a italic\_m italic\_p italic\_l italic\_i italic\_n italic\_g italic\_a italic\_n italic\_d italic\_s italic\_u italic\_b italic\_g italic\_r italic\_o italic\_u italic\_p italic\_a italic\_n italic\_a italic\_l italic\_y italic\_s italic\_i italic\_s ( ? , ? ) , italic\_a italic\_d italic\_v italic\_e italic\_r italic\_s italic\_a italic\_r italic\_i italic\_a italic\_l italic\_l italic\_e italic\_a italic\_r italic\_n italic\_i italic\_n italic\_g ( ? , ? , ? ) , italic\_r italic\_e italic\_w italic\_e italic\_i italic\_g italic\_h italic\_i italic\_n italic\_g ( ? , ? ) , italic\_a italic\_n italic\_d italic\_r italic\_e italic\_g italic\_u italic\_l italic\_a italic\_r italic\_i italic\_z italic\_a italic\_t italic\_i italic\_o italic\_n italic\_a italic\_n italic\_d italic\_c italic\_o italic\_n italic\_s italic\_t italic\_r italic\_a italic\_i italic\_n italic\_t italic\_o italic\_p italic\_t italic\_i italic\_m italic\_i italic\_z italic\_a italic\_t italic\_i italic\_o italic\_n ( ? , ? , ? ) . (2) Fair Regression. italic\_T italic\_h italic\_e italic\_g italic\_o italic\_a italic\_l italic\_o italic\_f italic\_f italic\_a italic\_i italic\_r italic\_r italic\_e italic\_g italic\_r italic\_e italic\_s italic\_s italic\_i italic\_o italic\_n italic\_i italic\_s italic\_t italic\_o italic\_j italic\_o italic\_i italic\_n italic\_t italic\_l italic\_y italic\_m italic\_i italic\_n italic\_i italic\_m italic\_i italic\_z italic\_e italic\_t italic\_h italic\_e italic\_d italic\_i italic\_f italic\_f italic\_e italic\_r italic\_e italic\_n italic\_c italic\_e italic\_b italic\_e italic\_t italic\_w italic\_e italic\_e italic\_n italic\_t italic\_r italic\_u italic\_e italic\_a italic\_n italic\_d italic\_p italic\_r italic\_e italic\_d italic\_i italic\_c italic\_t italic\_e italic\_d italic\_v italic\_a italic\_l italic\_u italic\_e italic\_s italic\_a italic\_n italic\_d italic\_e italic\_n italic\_s italic\_u italic\_r italic\_e italic\_f italic\_a italic\_i italic\_r italic\_n italic\_e italic\_s italic\_s . italic\_I italic\_t italic\_f italic\_o italic\_l italic\_l italic\_o italic\_w italic\_s italic\_t italic\_h italic\_e italic\_g italic\_e italic\_n italic\_e italic\_r italic\_a italic\_l italic\_f italic\_o italic\_r italic\_m italic\_u italic\_l italic\_a italic\_t italic\_i italic\_o italic\_n italic\_o italic\_f italic\_f italic\_a italic\_i italic\_r italic\_c italic\_l italic\_a italic\_s italic\_s italic\_i italic\_f italic\_i italic\_c italic\_a italic\_t italic\_i italic\_o italic\_n italic\_b italic\_u italic\_t italic\_w italic\_i italic\_t italic\_h italic\_c italic\_o italic\_n italic\_t italic\_i italic\_n italic\_u italic\_o italic\_u italic\_s italic\_r italic\_a italic\_t italic\_h italic\_e italic\_r italic\_t italic\_h italic\_a italic\_n italic\_b italic\_i italic\_n italic\_a italic\_r italic\_y / italic\_c italic\_a italic\_t italic\_e italic\_g italic\_o italic\_r italic\_i italic\_c italic\_a italic\_l italic\_t italic\_a italic\_r italic\_g italic\_e italic\_t italic\_v italic\_a italic\_r italic\_i italic\_a italic\_b italic\_l italic\_e . italic\_A italic\_c italic\_c italic\_o italic\_r italic\_d italic\_i italic\_n italic\_g italic\_l italic\_y , italic\_t italic\_h italic\_e italic\_f italic\_a italic\_i italic\_r italic\_n italic\_e italic\_s italic\_s italic\_d italic\_e italic\_f italic\_i italic\_n italic\_i italic\_t italic\_i italic\_o italic\_n , italic\_m italic\_e italic\_t italic\_r italic\_i italic\_c italic\_s , italic\_a italic\_n italic\_d italic\_t italic\_h italic\_e italic\_b italic\_a italic\_s italic\_i italic\_c italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_s italic\_a italic\_r italic\_e italic\_a italic\_d italic\_a italic\_p italic\_t italic\_e italic\_d italic\_f italic\_r italic\_o italic\_m italic\_c italic\_l italic\_a italic\_s italic\_s italic\_i italic\_f italic\_i italic\_c italic\_a italic\_t italic\_i italic\_o italic\_n italic\_t italic\_o italic\_r italic\_e italic\_g italic\_r italic\_e italic\_s italic\_s italic\_i italic\_o italic\_n . italic\_F italic\_o italic\_r italic\_e italic\_x italic\_a italic\_m italic\_p italic\_l italic\_e , italic\_i italic\_t italic\_i italic\_s italic\_s italic\_u italic\_g italic\_g italic\_e italic\_s italic\_t italic\_e italic\_d italic\_u italic\_s italic\_i italic\_n italic\_g italic\_s italic\_t italic\_a italic\_t italic\_i italic\_s italic\_t italic\_i italic\_c italic\_a italic\_l italic\_p italic\_a italic\_r italic\_i italic\_t italic\_y italic\_a italic\_n italic\_d italic\_b italic\_o italic\_u italic\_n italic\_d italic\_e italic\_d - italic\_g italic\_r italic\_o italic\_u italic\_p - italic\_l italic\_o italic\_s italic\_s italic\_m italic\_e italic\_t italic\_r italic\_i italic\_c italic\_s italic\_t italic\_o italic\_m italic\_e italic\_a italic\_s italic\_u italic\_r italic\_e italic\_f italic\_a italic\_i italic\_r italic\_n italic\_e italic\_s italic\_s italic\_i italic\_n italic\_r italic\_e italic\_g italic\_r italic\_e italic\_s italic\_s italic\_i italic\_o italic\_n ( ? ) . italic\_B italic\_i italic\_a italic\_s italic\_i italic\_n italic\_l italic\_i italic\_n italic\_e italic\_a italic\_r italic\_r italic\_e italic\_g italic\_r italic\_e italic\_s italic\_s italic\_i italic\_o italic\_n italic\_i italic\_s italic\_c italic\_o italic\_n italic\_s italic\_i italic\_d italic\_e italic\_r italic\_e italic\_d italic\_a italic\_s italic\_t italic\_h italic\_e italic\_e italic\_f italic\_f italic\_e italic\_c italic\_t italic\_s italic\_o italic\_f italic\_a italic\_s italic\_e italic\_n italic\_s italic\_i italic\_t italic\_i italic\_v italic\_e italic\_a italic\_t italic\_t italic\_r italic\_i italic\_b italic\_u italic\_t italic\_e italic\_o italic\_n italic\_t italic\_h italic\_e italic\_t italic\_a italic\_r italic\_g italic\_e italic\_t italic\_v italic\_a italic\_r italic\_i italic\_a italic\_b italic\_l italic\_e italic\_t italic\_h italic\_r italic\_o italic\_u italic\_g italic\_h italic\_t italic\_h italic\_e italic\_m italic\_e italic\_a italic\_n italic\_d italic\_i italic\_f italic\_f italic\_e italic\_r italic\_e italic\_n italic\_c italic\_e italic\_b italic\_e italic\_t italic\_w italic\_e italic\_e italic\_n italic\_g italic\_r italic\_o italic\_u italic\_p italic\_s italic\_a italic\_n italic\_d italic\_A italic\_U italic\_C italic\_m italic\_e italic\_t italic\_r italic\_i italic\_c italic\_s ( ? ) . italic\_O italic\_n italic\_e italic\_c italic\_o italic\_m italic\_m italic\_o italic\_n italic\_l italic\_y italic\_u italic\_s italic\_e italic\_d italic\_a italic\_p italic\_p italic\_r italic\_o italic\_a italic\_c italic\_h italic\_i italic\_n italic\_f italic\_a italic\_i italic\_r italic\_r italic\_e italic\_g italic\_r italic\_e italic\_s italic\_s italic\_i italic\_o italic\_n italic\_i italic\_s italic\_r italic\_e italic\_g italic\_u italic\_l italic\_a italic\_r italic\_i italic\_z italic\_a italic\_t italic\_i italic\_o italic\_n , italic\_e . italic\_g . , ( ? , ? ) . italic\_A italic\_p italic\_a italic\_r italic\_t italic\_f italic\_r italic\_o italic\_m italic\_f italic\_a italic\_i italic\_r italic\_m italic\_a italic\_c italic\_h italic\_i italic\_n italic\_e italic\_l italic\_e italic\_a italic\_r italic\_n italic\_i italic\_n italic\_g , italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_o italic\_p italic\_e italic\_r italic\_a italic\_t italic\_o italic\_r italic\_s italic\_a italic\_r italic\_e italic\_e italic\_n italic\_c italic\_o italic\_u italic\_r italic\_a italic\_g italic\_e italic\_d italic\_t italic\_o italic\_s italic\_h italic\_a italic\_r italic\_e italic\_e italic\_n italic\_o italic\_u italic\_g italic\_h italic\_d italic\_e italic\_t italic\_a italic\_i italic\_l italic\_s italic\_a italic\_b italic\_o italic\_u italic\_t italic\_h italic\_o italic\_w italic\_r italic\_e italic\_s italic\_e italic\_a italic\_r italic\_c italic\_h italic\_i italic\_s italic\_c italic\_a italic\_r italic\_r italic\_i italic\_e italic\_d italic\_o italic\_u italic\_t italic\_t italic\_o italic\_a italic\_l italic\_l italic\_o italic\_w italic\_o italic\_t italic\_h italic\_e italic\_r italic\_s italic\_t italic\_o italic\_r italic\_e italic\_p italic\_l italic\_i italic\_c italic\_a italic\_t italic\_e italic\_i italic\_t . italic\_T italic\_h italic\_i italic\_s italic\_i italic\_s italic\_a italic\_l italic\_e italic\_a italic\_p italic\_f italic\_o italic\_r italic\_m italic\_i italic\_t italic\_i italic\_g italic\_a italic\_t italic\_i italic\_n italic\_g italic\_b italic\_i italic\_a italic\_s italic\_a italic\_s italic\_i italic\_t italic\_h italic\_e italic\_l italic\_p italic\_s italic\_e italic\_n italic\_d - italic\_u italic\_s italic\_e italic\_r italic\_s italic\_w italic\_i italic\_t italic\_h italic\_d italic\_i italic\_f italic\_f italic\_e italic\_r italic\_e italic\_n italic\_t italic\_t italic\_e italic\_c italic\_h italic\_n italic\_i italic\_c italic\_a italic\_l italic\_b italic\_a italic\_c italic\_k italic\_g italic\_r italic\_o italic\_u italic\_n italic\_d italic\_t italic\_o italic\_u italic\_n italic\_d italic\_e italic\_r italic\_s italic\_t italic\_a italic\_n italic\_d italic\_h italic\_o italic\_w italic\_t italic\_h italic\_e italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_w italic\_o italic\_r italic\_k italic\_s italic\_b italic\_e italic\_f italic\_o italic\_r italic\_e italic\_m italic\_a italic\_k italic\_i italic\_n italic\_g italic\_a italic\_n italic\_y italic\_d italic\_e italic\_c italic\_i italic\_s italic\_i italic\_o italic\_n . italic\_I italic\_t italic\_i italic\_s italic\_a italic\_l italic\_s italic\_o italic\_s italic\_u italic\_g italic\_g italic\_e italic\_s italic\_t italic\_e italic\_d italic\_t italic\_h italic\_a italic\_t italic\_A italic\_I italic\_t italic\_e italic\_c italic\_h italic\_n italic\_o italic\_l italic\_o italic\_g italic\_i italic\_s italic\_t italic\_s italic\_a italic\_n italic\_d italic\_r italic\_e italic\_s italic\_e italic\_a italic\_r italic\_c italic\_h italic\_e italic\_r italic\_s italic\_d italic\_e italic\_v italic\_e italic\_l italic\_o italic\_p italic\_a italic\_b italic\_i italic\_a italic\_s italic\_i italic\_m italic\_p italic\_a italic\_c italic\_t italic\_s italic\_t italic\_a italic\_t italic\_e italic\_m italic\_e italic\_n italic\_t italic\_a italic\_s italic\_a italic\_s italic\_e italic\_l italic\_f - italic\_r italic\_e italic\_g italic\_u italic\_l italic\_a italic\_t italic\_o italic\_r italic\_y italic\_p italic\_r italic\_a italic\_c italic\_t italic\_i italic\_c italic\_e . italic\_I italic\_t italic\_c italic\_a italic\_n italic\_h italic\_e italic\_l italic\_p italic\_p italic\_r italic\_o italic\_b italic\_e italic\_a italic\_n italic\_d italic\_a italic\_v italic\_e italic\_r italic\_t italic\_a italic\_n italic\_y italic\_p italic\_o italic\_t italic\_e italic\_n italic\_t italic\_i italic\_a italic\_l italic\_b italic\_i italic\_a italic\_s italic\_e italic\_s italic\_t italic\_h italic\_a italic\_t italic\_a italic\_r italic\_e italic\_i italic\_n italic\_j italic\_e italic\_c italic\_t italic\_e italic\_d italic\_i italic\_n italic\_t italic\_o italic\_o italic\_r italic\_r italic\_e italic\_s italic\_u italic\_l italic\_t italic\_a italic\_n italic\_t italic\_f italic\_r italic\_o italic\_m italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_i italic\_c italic\_d italic\_e italic\_c italic\_i italic\_s italic\_i italic\_o italic\_n ( ? ) . italic\_S italic\_o italic\_m italic\_e italic\_e italic\_x italic\_a italic\_m italic\_p italic\_l italic\_e italic\_q italic\_u italic\_e italic\_s italic\_t italic\_i italic\_o italic\_n italic\_s italic\_i italic\_n italic\_t italic\_h italic\_e italic\_s italic\_t italic\_a italic\_t italic\_e italic\_m italic\_e italic\_n italic\_t italic\_a italic\_r italic\_e ` ` italic\_W italic\_h italic\_a italic\_t italic\_w italic\_i italic\_l italic\_l italic\_t italic\_h italic\_e italic\_a italic\_u italic\_t italic\_o italic\_m italic\_a italic\_t italic\_e italic\_d italic\_d italic\_e italic\_c italic\_i italic\_s italic\_i italic\_o italic\_n italic\_d italic\_o ? start\_POSTSUPERSCRIPT ′ ′ end\_POSTSUPERSCRIPT , ` ` italic\_H italic\_o italic\_w italic\_w italic\_i italic\_l italic\_l italic\_p italic\_o italic\_t italic\_e italic\_n italic\_t italic\_i italic\_a italic\_l italic\_b italic\_i italic\_a italic\_s italic\_b italic\_e italic\_d italic\_e italic\_t italic\_e italic\_c italic\_t italic\_e italic\_d ? start\_POSTSUPERSCRIPT ′ ′ end\_POSTSUPERSCRIPT , italic\_a italic\_n italic\_d ` ` italic\_W italic\_h italic\_a italic\_t italic\_a italic\_r italic\_e italic\_t italic\_h italic\_e italic\_o italic\_p italic\_e italic\_r italic\_a italic\_t italic\_o italic\_r italic\_i italic\_n italic\_c italic\_e italic\_n italic\_t italic\_i italic\_v italic\_e italic\_s start\_POSTSUPERSCRIPT ′ ′ end\_POSTSUPERSCRIPT . italic\_I italic\_n italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_d italic\_e italic\_s italic\_i italic\_g italic\_n , italic\_r italic\_e italic\_s italic\_e italic\_a italic\_r italic\_c italic\_h italic\_e italic\_r italic\_s italic\_a italic\_r italic\_e italic\_a italic\_l italic\_s italic\_o italic\_r italic\_e italic\_s italic\_p italic\_o italic\_n italic\_s italic\_i italic\_b italic\_l italic\_e italic\_t italic\_o italic\_e italic\_n italic\_c italic\_o italic\_u italic\_r italic\_a italic\_g italic\_e italic\_t italic\_h italic\_e italic\_r italic\_o italic\_l italic\_e italic\_o italic\_f italic\_d italic\_i italic\_v italic\_e italic\_r italic\_s italic\_i italic\_t italic\_y italic\_w italic\_i italic\_t italic\_h italic\_i italic\_n italic\_t italic\_h italic\_e italic\_t italic\_e italic\_a italic\_m , italic\_t italic\_r italic\_a italic\_i italic\_n italic\_i italic\_n italic\_g italic\_d italic\_a italic\_t italic\_a , italic\_a italic\_n italic\_d italic\_t italic\_h italic\_e italic\_l italic\_e italic\_v italic\_e italic\_l italic\_o italic\_f italic\_c italic\_u italic\_l italic\_t italic\_u italic\_r italic\_a italic\_l italic\_s italic\_e italic\_n italic\_s italic\_i italic\_t italic\_i italic\_v italic\_i italic\_t italic\_y . italic\_T italic\_h italic\_e ` ` italic\_d italic\_i italic\_v italic\_e italic\_r italic\_s italic\_i italic\_t italic\_y - italic\_i italic\_n - italic\_d italic\_e italic\_s italic\_i italic\_g italic\_n start\_POSTSUPERSCRIPT ′ ′ end\_POSTSUPERSCRIPT italic\_m italic\_e italic\_c italic\_h italic\_a italic\_n italic\_i italic\_s italic\_m italic\_a italic\_i italic\_m italic\_s italic\_t italic\_o italic\_t italic\_a italic\_k italic\_e italic\_d italic\_e italic\_l italic\_i italic\_b italic\_e italic\_r italic\_a italic\_t italic\_e italic\_a italic\_n italic\_d italic\_t italic\_r italic\_a italic\_n italic\_s italic\_p italic\_a italic\_r italic\_e italic\_n italic\_t italic\_a italic\_c italic\_t italic\_i italic\_o italic\_n italic\_s italic\_t italic\_o italic\_a italic\_d italic\_d italic\_r italic\_e italic\_s italic\_s italic\_t italic\_h italic\_e italic\_u italic\_p italic\_f italic\_r italic\_o italic\_n italic\_t italic\_c italic\_u italic\_l italic\_t italic\_u italic\_r italic\_a italic\_l italic\_b italic\_i italic\_a italic\_s italic\_e italic\_s italic\_a italic\_n italic\_d italic\_s italic\_t italic\_e italic\_r italic\_e italic\_o italic\_t italic\_y italic\_p italic\_e italic\_s . italic\_F italic\_u italic\_r italic\_t italic\_h italic\_e italic\_r italic\_m italic\_o italic\_r italic\_e , italic\_w italic\_e italic\_m italic\_i italic\_g italic\_h italic\_t italic\_a italic\_l italic\_s italic\_o italic\_c italic\_o italic\_n italic\_s italic\_i italic\_d italic\_e italic\_r italic\_u italic\_p italic\_d italic\_a italic\_t italic\_i italic\_n italic\_g italic\_n italic\_o italic\_n italic\_d italic\_i italic\_s italic\_c italic\_r italic\_i italic\_m italic\_i italic\_n italic\_a italic\_t italic\_i italic\_o italic\_n italic\_a italic\_n italic\_d italic\_o italic\_t italic\_h italic\_e italic\_r italic\_c italic\_i italic\_v italic\_i italic\_l italic\_r italic\_i italic\_g italic\_h italic\_t italic\_s italic\_l italic\_a italic\_w italic\_s italic\_t italic\_o italic\_i italic\_n italic\_t italic\_e italic\_r italic\_p italic\_r italic\_e italic\_t italic\_a italic\_n italic\_d italic\_r italic\_e italic\_d italic\_r italic\_e italic\_s italic\_s italic\_o italic\_n italic\_l italic\_i italic\_n italic\_e italic\_d italic\_i italic\_s italic\_p italic\_a italic\_r italic\_a italic\_t italic\_e italic\_i italic\_m italic\_p italic\_a italic\_c italic\_t italic\_s ( ? ) . italic\_A italic\_n italic\_e italic\_x italic\_a italic\_m italic\_p italic\_l italic\_e italic\_o italic\_f italic\_s italic\_u italic\_c italic\_h italic\_c italic\_o italic\_n italic\_s italic\_i italic\_d italic\_e italic\_r italic\_a italic\_t italic\_i italic\_o italic\_n italic\_i italic\_s italic\_t italic\_o italic\_u italic\_n italic\_a italic\_m italic\_b italic\_i italic\_g italic\_u italic\_o italic\_u italic\_s italic\_l italic\_y italic\_d italic\_e italic\_f italic\_i italic\_n italic\_e italic\_t italic\_h italic\_e italic\_t italic\_h italic\_r italic\_e italic\_s italic\_h italic\_o italic\_l italic\_d italic\_s italic\_a italic\_n italic\_d italic\_p italic\_a italic\_r italic\_a italic\_m italic\_e italic\_t italic\_e italic\_r italic\_s italic\_f italic\_o italic\_r italic\_t italic\_h italic\_e italic\_d italic\_i italic\_s italic\_p italic\_a italic\_r italic\_a italic\_t italic\_e italic\_t italic\_r italic\_e italic\_a italic\_t italic\_m italic\_e italic\_n italic\_t italic\_s italic\_o italic\_f italic\_p italic\_r italic\_o italic\_t italic\_e italic\_c italic\_t italic\_e italic\_d italic\_g italic\_r italic\_o italic\_u italic\_p italic\_s italic\_b italic\_e italic\_f italic\_o italic\_r italic\_e italic\_t italic\_h italic\_e italic\_a italic\_l italic\_g italic\_o italic\_r italic\_i italic\_t italic\_h italic\_m italic\_d italic\_e italic\_s italic\_i italic\_g italic\_n .
5 Open Problems and Challenges
-------------------------------
This survey reveals that the current understanding of SRAs is insufficient and future efforts are in great need. Here, we describe several primary challenges, as summarized in Figure [8](#S5.F8 "Figure 8 ‣ 5 Open Problems and Challenges ‣ Socially Responsible AI Algorithms: Issues, Purposes, and Challenges"), in an attempt to broaden the discussions on future directions and potential solutions.
Figure 8: Primary challenges and open problems we confront in developing SRAs. Some challenges relate to SRAs’ internal mechanisms that fulfill AI’s ethical responsibilities whilst others relate to SRAs’ roles to which both ethical and philanthropic responsibilities are the keys.
Causal Learning. The correlation fallacy causes AI algorithms to meet with fundamental obstacles in order to commit social responsibility. These obstacles are robustness, explainability, and cause-effect connections (?). The era of big data has changed the ways of learning causality, and meanwhile, causal learning becomes an indispensable ingredient for AI systems to achieve human-level intelligence. There are a number of benefits to incorporate causality in the next-generation of AI. For example, teaching AI algorithms to understand “why” can help them transfer their knowledge to different but similar domains. Early efforts in SRAs attempted to employ causal learning concept and methods such as intervention, counterfactual, do-calculus, propensity scoring to address fairness (e.g., counterfactual fairness) and interpretability (causal interpretability) issues. They have shown prominent results in these tasks.
Context Matters. Context is the core to SRAs due to its inherently elaborate nature, e.g., the “Transparency Paradox”. Understanding and quantifying the relationships among the various principles (some are tradeoffs and some are not), e.g., fairness, transparency, and safety, have to be placed in specific context. One such context is the social context. Existing SRAs (e.g., fair machine learning), once introduced into a new social context, may render current technical interventions ineffective, inaccurate, and even dangerously misguided (?). A recent study (?) found that while fair ranking algorithms such as Det-Greedy (?) help increase the exposure of minority candidates, their effectiveness is limited by the job contexts in which employers have a preference to particular genders. How to properly integrate social context into SRAs is still an open problem. Algorithmic context (e.g., supervised learning, unsupervised learning, and reinforcement learning) is also extremely important when designing SRAs for the given data. A typical example is the feedback loop problem in predictive policing (?). A subtle algorithmic choice can have huge ramifications on the results. Consequently, we need to understand the algorithmic context to make the right algorithmic choices when designing socially responsible AI systems. Designing context-aware SRAs is the key to achieving Social Responsibility of AI.
Responsible Model Release and Governance. Nontransparent model reporting is one of the main causes of AI indifferent behaviors. As a critical step to clarify the intended use cases of AI systems and the contexts for which they are well suited, responsible model release and governance has been receiving growing attentions from both industry and academia. One role of SRAs is to bring together the tools, solutions, practices, and people to govern the built AI systems across its life cycle (?). At this early stage, some research results suggested that released models be accompanied by documentation detailing various characteristics of the systems, e.g., what it does, how it works, and why it matters. For example, the AI FactSheets (?) advocates to use a factsheet completed and voluntarily released by AI developers to increase the transparency of their services. A similar concept is model cards (?), short documents that provide benchmarked evaluation for the trained AI models in a variety of conditions, e.g., different cultural or demographic groups. Typically, a model card should include the model details, intended use, evaluation metrics, training/evaluation data, ethical considerations, and caveats and recommendations. To help increase transparency, manage risk, and build trust in AI, AI technologists and researchers are responsible to address various challenges faced in creating useful AI release documentation (?) and develop effective AI governance tools.
AI Defenses. Developing AI systems that outwit malicious AI is still at an early stage (?). Since we have not fully understood how AI systems work, they are not only vulnerable to attack but also likely to fail in surprising ways (?, ?). As a result, it is critical and urgent to work on designing systems that are provably robust to help ensure that the AI systems are not vulnerable to adversaries. At least two capabilities an “AI firewall” needs to be equipped with: one capability is to probe an AI algorithm for weaknesses (e.g., perturb the input of an AI system to make it misbehave) and the other one is to automatically intercept potentially problematic inputs. Some big tech companies have started building their own AI defenses to identify the weak spots, e.g., the “red team” in Facebook, the software framework released by Microsoft, Nvidia, IBM, and 9 other companies. AI defenses reflect the fundamental weakness in modern AI and make AI systems more robust and intelligent.
AI Ethics Principles and Policies. Current AI principles and policies for ethical practice have at least two common criticisms: (1) they are too vaguely formulated to prove to be helpful in guiding practice; and (2) they are defined primarily by AI researchers and powerful people with mainstream populations in mind (?). For the first criticism, to help operationalize AI principles in practice and organizations confront inevitable value trade-offs, it has been suggested to redefine AI principles based on philosophical theories in applied ethics (?). Particularly, it categorizes published AI principles (e.g., fairness, accountability, and transparency) into three widely used core principles in applied ethics: autonomy, beneficence (avoiding harm and doing good), and justice. The core principles “invoke those values that theories in moral and political philosophy argue to be intrinsically valuable, meaning their value is not derived from something else” (?). Existing AI principles are instrumental principles that “build on concepts whose values are derived from their instrumental effect in protecting and promoting intrinsic values” (?). Operationazable AI principles help effectively put ethical AI in practice and reduce the responsible AI Gap in companies. To address the second criticism, we need to best elicit the inputs and values of diverse voices from the Subjects of SRAs, i.e., the minority and disadvantaged groups, and incorporate their perspectives into the tech policy document design process. If we align values of AI systems through a panel of people (who are compensated for doing this), they too can influence the system behavior, and not just the powerful people or AI researchers.
Understanding Why. Many AI systems are designed and developed without fully understanding why: What do we wish the AI system do? This is often the reason that these systems fail to represent the goals of the real tasks, a primary source of AI risks. The problem can become more challenging when the AI system is animated through a number of lines of code that lack nuance, creating a machine that does not align with our true intentions. As the first step, understanding why clearly defines our social expectation of AI systems and paves way for more specific questions such as “What is the problem? Who will define it? and what are the right people to include?”. Answering why helps us effectively abolish the development of socially indifferent AI systems in the first place and also helps understand the kinds of deception an AI system may learn by itself.
Long-Term Effect. SRAs include social concepts such as fairness that can evolve over time along with the constant changes of human values and social dynamics. This raises the concerns about the commitment SRAs need to fulfill in the long term. For example, despite the various types of fairness definitions, once introduced into the dimension of time, the number of fairness definitions may be explosive. In addition, current fairness criteria may be considered as unfair in the future. Fairness criteria are essentially designed to promote long-term well-being. However, even a static fairness notion can fail to protect the target groups when there is a feedback loop in the overall system (?). How to build AI systems that can commit long-term responsibility is extremely challenging and rarely studied thus far. Initial results of long-term fairness (?, ?) highlight the importance of measurement and temporal modeling in the evaluation of fairness criteria.
Humans in the Loop. While existing techniques in SRAs have indeed made significant progress towards responsible AI systems, their usefulness can be limited in some settings where the decisions made are actually poorer for every individual. For issues of fairness in prediction, for example, many findings (e.g., ?) have shown the concerns about the fairness-performance trade-off: the imposition of fairness comes at a cost to model performance. Predictions are less reliable and moreover, different notions of fairness can make approaches to fairness conflict with one another. Having human in the loop matters when it comes to contextualizing the objectives of SRAs, especially for high-stake decisions. For instance, there are situations where the cut-off values of fairness for two subgroups are different, and humans can help calibrate the differences.
Responsible AI Gap in Industry. The far-reaching effect of reputational damage and employee disengagement result from AI misbehavior has forced company executives to begin understanding the risks of poorly designed AI systems and the importance of SRAs. While seeing many potential benefits of developing responsible AI systems such as increasing market share and long-term profitability, companies lack the knowledge of how to cross the “Responsible AI Gap” between principles and tangible actions (?). This is partly because companies view responsible AI solely as risk-avoidance mechanism and overlook its financial rewards. To capture the benefits of responsible AI in companies’ day-to-day business, companies need to go far beyond SRAs and examine every aspect of the end-to-end AI systems. A recent article (?) suggested six basic steps to bridge the gulf between responsible AI and the reality: Empower responsible AI leadership, Develop principles, policies, and training, Establish human and AI governance, Conduct Responsible AI reviews, Integrate tools and methods, and Build and test a response plan. Even though the gap might be huge, small efforts built over time can let SRAs achieve a transformational impact on the businesses.
Interdisciplinary Research. Current public dialog on SRAs has been focused on a narrow subset of fields, blinding us to the opportunities presented by interdisciplinary research. It is necessary to work with researchers from different disciplines whose contributions are sorely needed, e.g., psychologist, social scientist, educators, and humanities. Non-profit organizations are both the beneficiaries and benefactors of SRAs. In partnering with non-profits and social enterprises will not only unleash AI’s potential for benefiting societal well-being, but also let AI technologists and researchers have the opportunity to encounter the real problems we are currently facing. A better understanding of what problems need to be solved helps identify SRAs that need to be created. Moreover, as big tech companies bankroll more work of academic researchers, much of ethics-based research gets concentrated in the hands of a few companies that can afford it (?). This is problematic because we are over reliant on the same companies that are producing socially indifferent AI systems. We need interdisciplinary and decentralized research to create SRAs and simultaneously achieve the four levels in the pyramid of Social Responsibility of AI.
SRAs for Social Good. The last challenge regards the intended use of SRAs. When SRAs are leveraged to uplift humanity, a trust in AI is further enhanced. There has been a burgeoning of AI-for-social-good movement that produces AI algorithms to help reduce poverty, hunger, inequality, injustice, climate change, ill health, and other causes of human suffering (?). Compared to deploying cutting-edge AI systems to solve these critical issues, a more urgent question to examine is “What makes an AI project good” in order to prevent the detrimental consequences of AI. In addition to Protecting, Informing, and Preventing, social good applications also relate closely to Fundraise and Greenlight (?). Applying SRAs to target solicitations for donations largely helps with fundraising for non-profits, charitable organizations, and universities. Greenlight describes how SRAs can help allocate grants and other types of resources by predicting the success rates of project proposals. It plays an important role in improving execution effectiveness of organizations. Developing social good applications that leverage power of SRAs to benefit society is an equally endeavor for AI technologists and researchers.
6 Conclusion
-------------
This survey examines multiple dimensions of research in Social Responsibility of AI, seeking to broaden the current discussions primarily focused on decision-making algorithms that perform scoring and classification tasks. We argue that having a full scope of AI to capture the connections among all the major dimensions is the key to Socially Responsible AI Algorithms (SRAs). This work starts with an inclusive definition of Social Responsibility of AI, highlighting the principles (e.g., Fairness, Inclusiveness), means (e.g., SRAs), and objective (e.g., improving humanity). To better frame the Social Responsibility of AI, we also introduce the pyramid with four-level responsibilities of AI systems: functional responsibilities, legal responsibilities, ethical responsibilities, and philanthropic responsibilities. We then focus our discussions on how to achieve Social Responsibility of AI via the proposed framework SRAs. In the definition of SRAs, we emphasize that the functional and societal aspects are integral parts of AI algorithms. Given that both the functional and legal responsibilities are the usual focuses in AI research and development, we particularly investigate the essentials to achieve AI’s ethical responsibilities: the subjects, causes, objectives, and means. For the intended use (i.e., roles) of SRAs, we discuss the need of philanthropic and ethical responsibilities for AI systems to protect and inform users, and prevent/mitigate the negative impact. We conclude with several open problems and major challenges in SRAs. At this pivotal moment in the development of AI, it is of vital importance to discuss AI ethics and specify Social Responsibility of AI. Drawing from the theory of moral license (?) – when humans are good, we give ourselves moral license to be bad – we argue that simply asking AI to do good is insufficient and inefficient, and more can be done for AI technologists and researchers to develop socially responsible AI systems. We hope this work can propel future research in various fields to tackle together the challenges and steer a course towards a beneficial AI future.
Acknowledgements
----------------
This material is based upon work supported by, or in part by, the U.S. Army Research Laboratory (ARL), the U.S. Army Research Office (ARO), the Office of Naval Research (ONR) under contract/grant numbers W911NF2110030, W911NF2020124, and N00014-21-1-4002, as well as by the National Science Foundation (NSF) grants 1909555 and 2036127. We thank Dr. Lise Getoor and Dr. Hosagrahar V. Jagadish for their invaluable suggestions. |
fdde930c-c07f-4db4-b630-dc067a2e5168 | trentmkelly/LessWrong-43k | LessWrong | Polis: Why and How to Use it
Polis is a surveying platform designed for finding clusters of people with similar opinions on a topic. Participants submit short text statements(<140 characters) which are sent out semi-randomly[1] to other participants to vote on by clicking agree, disagree or pass.
This post provides links to video and text tutorials for using polis.
When can Polis be Useful?
* Identify subgroups of readers/users who you can then target more specifically
* Understand better the types of people attending your university EA group
* Survey opinions on how the EA community should be structured
* Get suggestions for a new project for your organisation that are widely agreed upon in a given community
* Understand the beliefs of a group of people affected by your project (e.g. AI researchers, parents in Nigeria, people new to EA)
Tutorials
This tutorial from Computational Democracy is a good introduction:
> Polis is a 💡 Wikisurvey, as:
>
> * the dimensions of the survey are created by the participants themselves
> * the survey adapts to participation over time and makes good use of people's time by showing comments semi-randomly
> * participants do not need to complete the entire survey to contribute meaning
>
> pol.is is the main instance of the technology hosted online, but there are other instances in the wild.
>
> In its highest ambition, Polis is a platform for enabling collective intelligence in human societies and fostering mutual understanding at scale in the tradition of nonviolent communication.
A good tutorial based on a worked example is available here:
> The text input to seed statements can be found in the ‘configure’ tab once you’ve started your conversation, seen at left.
>
> It’s usually a good idea to seed around 10–15 diverse comments. This has a powerful effect on early participation. We’ve found that about 1 in 10 people leave a comment (whereas 9 in 10 only agree disagree and pass on statements submitted by others). Given this ratio, if the |
8f4007b0-6cde-4dba-ac46-420d9d3c5eff | trentmkelly/LessWrong-43k | LessWrong | Conformity
A rather good 10 minute YouTube video presenting the results of several papers relevant to how conformity affects our thinking:
http://www.youtube.com/watch?v=TrNIuFrso8I
The papers mentioned are:
Sherif, M. (1935). A study of some social factors in perception. Archives of Psychology, 27(187), pp.17-22.
Asch, S.E. (1951). Effects of group pressure upon the modification and distortion of judgment. In H. Guetzkow (ed.) Groups, leadership and men. Pittsburgh, PA: Carnegie Press.
Asch, S.E. (1955). Opinions and social pressure. Scientific American, 193(5), pp.31-35.
Berns, G.S., Chappelow, J., Zink, C.F., Pagnoni, G., Martin-Skurski, M.E., and Richards, J. (2005) 'Neurobiological Correlates of Social Conformity and Independence During Mental Rotation' Biological Psychiatry, 58(3), pp.245-253.
Weaver, K., Garcia, S.M., Schwarz, N., & Miller, D.T. (2007) Inferring the popularity of an opinion from its familiarity: A repetitive voice can sound like a chorus. Journal of Personality and Social Psychology, 92(5), 821-833.
What techniques do other posters, here on LessWrong, use to monitor and counter these effects in their lives?
The video also lists some of the advantages to a society of having a certain amount of this effect in place. Does anyone here conform too little? |
4254c9db-5685-4227-a16d-7dbf910a801a | trentmkelly/LessWrong-43k | LessWrong | Group Rationality Diary, April 15-29
This is the public group instrumental rationality diary for April 15-29.
> It's a place to record and chat about it if you have done, or are actively doing, things like:
>
> * Established a useful new habit
> * Obtained new evidence that made you change your mind about some belief
> * Decided to behave in a different way in some set of situations
> * Optimized some part of a common routine or cached behavior
> * Consciously changed your emotions or affect with respect to something
> * Consciously pursued new valuable information about something that could make a big difference in your life
> * Learned something new about your beliefs, behavior, or life that surprised you
> * Tried doing any of the above and failed
>
> Or anything else interesting which you want to share, so that other people can think about it, and perhaps be inspired to take action themselves. Try to include enough details so that everyone can use each other's experiences to learn about what tends to work out, and what doesn't tend to work out.
Thanks to cata for starting the Group Rationality Diary posts, and to commenters for participating!
Next diary: May 1-15
Immediate past diary: April 5-14
Rationality Diaries archive
|
7bfcd275-7386-41ab-b894-a3caed1cd9a4 | trentmkelly/LessWrong-43k | LessWrong | SI is coming to Oxford, looking for hosts, trying to keep costs down
The Singularity Institute is coming to Oxford, England for AGI-2012!
AGI-2012 runs December 8th–11th, but many of us will be arriving as early as the 6th or 7th, and some will be leaving as late as the 16th. We are looking for generous members of the Less Wrong community who would be willing to host us during our visit.
Who's coming?
* Luke Muehlhauser
* Louie Helm
* Carl Shulman
* Alex Altair
* Malo Bourgon
* Anja Heinisch
Why you might want to host us?
* You want to help SI save some money.
* You want to see Luke Meuhlhauser fact #8 for yourself.
* You want to hangout with us, which is great, because we also want to hangout with you.
* You want to marvel at Louie's boyish good looks in person.
If you live close to Oxford and have a spare bed, a futon, a comfortable couch, a not so comfortable couch, an inflatable mattress etc.—and would be willing to put one or more of us up for one or more nights—please email malo@intelligence.org with the following information:
* your location,
* what dates you can host one or more of us, and
* how many of us you're able/willing to put up with :) |
61c2b923-6a8e-4a58-8ada-a2d1889299f8 | trentmkelly/LessWrong-43k | LessWrong | The Useful Idea of Truth
(This is the first post of a new Sequence, Highly Advanced Epistemology 101 for Beginners, setting up the Sequence Open Problems in Friendly AI. For experienced readers, this first post may seem somewhat elementary; but it serves as a basis for what follows. And though it may be conventional in standard philosophy, the world at large does not know it, and it is useful to know a compact explanation. Kudos to Alex Altair for helping in the production and editing of this post and Sequence!)
----------------------------------------
I remember this paper I wrote on existentialism. My teacher gave it back with an F. She’d underlined true and truth wherever it appeared in the essay, probably about twenty times, with a question mark beside each. She wanted to know what I meant by truth.
-- Danielle Egan
I understand what it means for a hypothesis to be elegant, or falsifiable, or compatible with the evidence. It sounds to me like calling a belief ‘true’ or ‘real’ or ‘actual’ is merely the difference between saying you believe something, and saying you really really believe something.
-- Dale Carrico
What then is truth? A movable host of metaphors, metonymies, and; anthropomorphisms: in short, a sum of human relations which have been poetically and rhetorically intensified, transferred, and embellished, and which, after long usage, seem to a people to be fixed, canonical, and binding.
-- Friedrich Nietzche
----------------------------------------
The Sally-Anne False-Belief task is an experiment used to tell whether a child understands the difference between belief and reality. It goes as follows:
The child sees Sally hide a marble inside a covered basket, as Anne looks on.
Sally leaves the room, and Anne takes the marble out of the basket and hides it inside a lidded box.
Anne leaves the room, and Sally returns.
The experimenter asks the child where Sally will look for her marble.
Children under the age of four say that Sally will look for her marble inside th |
2e390de1-dfa7-4788-b354-2ad1dbb171bf | trentmkelly/LessWrong-43k | LessWrong | Learning the prior and generalization
This post is a response to Paul Christiano's post “Learning the prior.”
The generalization problem
Generally, when we train models, we often end up deploying them in situations that are distinctly different from those they were trained under. Take, for example, GPT-3. GPT-3 was trained to predict web text, not serve as a dungeon master—and the sort of queries that people present to AI dungeon are quite different than random web text—but nevertheless GPT-3 can perform quite well here because it has learned a policy which is general enough that it continues to function quite effectively in this new domain.
Relying on this sort of generalization, however, is potentially quite troublesome. If you're in a situation where your training and deployment data are in fact independently and identically distributed (i.i.d.), you can produce all sorts of nice guarantees about the performance of your model. For example, in an i.i.d. setting, you know that in the limit of training you'll get the desired behavior. Furthermore, even before the limit of training, you know that validation and deployment performance will precisely track each other such that you can bound the probability of catastrophic behavior by the incidence of catastrophic behavior on the validation data.
In a generalization setting, on the other hand, you have no such guarantees—even in the limit of training, precisely what your model does off-distribution is determined by your training process's inductive biases. In theory, any off-distribution behavior is compatible with zero training error—the only reason machine learning produces good off-distribution behavior is because it finds something like the simplest model that fits the data. As a result, however, a model's off-distribution behavior will be highly dependent on exactly what the training process's interpretation of “simpler” is—that is, its inductive biases. And relying on such inductive biases for your generalization behavior can potentially have cata |
7b27b94d-5eb5-465c-9f99-ce07cace0ce5 | trentmkelly/LessWrong-43k | LessWrong | Meetup : Vancouver New Year!
Discussion article for the meetup : Vancouver New Year!
WHEN: 30 December 2012 01:00:00PM (-0800)
WHERE: Benny's Bagels 2505 w broadway, vancouver
Hello vancouver lesswrongers,
Goddam Christmas is done creating chaos and now it's time to start a new year (judging the new year by the sun...) of Vancouver LW meetups!
Come on out to Benny's Bagels in Kitsilano to meet up with like-minded aspiring rationalists, talk about all sorts of stuff, and generally have fun. 13:00 on Sunday the 30th.
If you are looking for an excuse to start coming out, the new year seems as good as any.
See you there!
Discussion article for the meetup : Vancouver New Year! |
3b171a86-5586-4b03-878f-e863abf67600 | trentmkelly/LessWrong-43k | LessWrong | What technologies could cause world GDP doubling times to be <8 years?
Some people think GDP is a good metric for AI timelines and takeoff speeds, and that the world economy will double in 4 years before the start of the first 1-year doubling period, and that AGI will happen after the economy is already growing much faster than it is today.
Other than AGI, what technologies could significantly accelerate world GDP growth? (Say, to a doubling period of <8 years, meaning the whole world economy grows 9%+ per year, significantly faster than the fastest-growing countries today.)
I find myself struggling to think of plausible answers to this question. Here are some ideas:
--Cheap energy, e.g. from solar panels or fusion
--Cheap resources, e.g. from asteroid mining, undersea mining, automated mines...
--Robots and self-driving cars make transportation and manufacturing cheaper
--3D printing? Idk.
--Narrow AI? Seems like the most plausible answer, but narrow AI doing what, exactly? Driving cars? Manufacturing things? Already discussed that. Inventing new products? OK, but in that case won't they also invent AGI?
My problem is that while all of these things seem like they could be a big deal by ordinary standards, they don't seem like that big a deal. Looking back over US economic history, it seems to my quick glance that growth rates haven't changed much in 200 years. (!!!) But over that time energy, resources, etc. have gotten lots cheaper in the USA, and all sorts of new tech has been developed. Worldwide, it looks like the last time annual GWP growth was less than half of what it is now (excluding the Great Depression) was... 1875! (At least according to my data, would love to see a more thorough investigation of this). The world looked hella different in 1875 than it does now in 2020; doubling world GDP growth rates again seems like a pretty tall order. I believe that AGI could do it, but what else could? |
b47a5379-07d6-4e21-8e02-f79adcc55e68 | trentmkelly/LessWrong-43k | LessWrong | Dutch book question
I'm following Jack's Dutch book discussion with interest and would like to know about the computational complexity of constructing a Dutch book. If I give you a finite table of probabilities, is there a polynomial time algorithm that will verify that it is or is not Dutch bookable? Or: help me make this question better-posed.
It reminds me of Boolean satisfiability, which is known to be NP complete, but maybe the similarity is superficial. |
f02ea050-6148-438f-bf48-a679f9d2346b | trentmkelly/LessWrong-43k | LessWrong | Kevin Simler's "Going Critical"
An interactive blogpost by Kevin Simler on network dynamics, with a final section on academia and intellectual progress. I generally think careful exploration of small-scale simulations like this can help quite well with understanding difficult topics, and this post seems like a quite good execution of that approach.
Also some interesting comments on intellectual progress and academia (though I recommend reading the whole post):
> For years I've been fairly dismissive of academia. A short stint as a PhD student left a bad taste in my mouth. But now, when I step back and think about it (and abstract away all my personal issues), I have to conclude that academia is still extremelyimportant.
> Academic social networks (e.g., scientific research communities) are some of the most refined and valuable structures our civilization has produced. Nowhere have we amassed a greater concentration of specialists focused full-time on knowledge production. Nowhere have people developed a greater ability to understand and critique each other's ideas. This is the beating heart of progress. It's in these networks that the fire of the Enlightenment burns hottest.
> But we can't take progress for granted. If the reproducibility crisis has taught us anything, it's that science can have systemic problems. And one way to look at those problems is network degradation.
> Suppose we distinguish two ways of practicing science: Real Science vs. careerist science. Real Science is whatever habits and practices reliably produce knowledge. It's motivated by curiosity and characterized by honesty. (Feynman: "I just have to understand the world, you see.") Careerist science, in contrast, is motivated by professional ambition, and characterized by playing politics and taking scientific shortcuts. It may look and act like science, but it doesn't produce reliable knowledge.
> (Yes this is an exaggerated dichotomy. It's a thought exercise. Bear with me.)
> Point is, when careerists take up space |
437bd10c-2007-4704-a863-b278c58f1f96 | StampyAI/alignment-research-dataset/lesswrong | LessWrong | What Program Are You?
I've been trying for a while to make sense of the various alternate decision theories discussed here at LW, and have kept quiet until I thought I understood something well enough to make a clear contribution. Here goes.
You simply cannot reason about what to do by referring to what program you run, and considering the other instances of that program, for the simple reason that: *there is no unique program that corresponds to any physical object.*
Yes, you can think of many physical objects O as running a program P on data D, but there are many many ways to decompose an object into program and data, as in O = <P,D>. At one extreme you can think of every physical object as running exactly the same program, i.e., the laws of physics, with its data being its particular arrangements of particles and fields. At the other extreme, one can think of each distinct physical state as a distinct program, with an empty unused data structure. Inbetween there are an astronomical range of other ways to break you into your program P and your data D.
Eliezer's descriptions of his "Timeless Decision Theory", however refer often to "the computation" as distinguished from "its input" in this "instantiation" as if there was some unique way to divide a physical state into these two components. [For example](/lw/15z/ingredients_of_timeless_decision_theory/):
The one-sentence version is: Choose as though controlling the logical output of the abstract computation you implement, including the output of all other instantiations and simulations of that computation.
The three-sentence version is: Factor your uncertainty over (impossible) possible worlds into a causal graph that includes nodes corresponding to the unknown outputs of known computations; condition on the known initial conditions of your decision computation to screen off factors influencing the decision-setup; compute the counterfactuals in your expected utility formula by surgery on the node representing the logical output of that computation.
[And also](/lw/164/timeless_decision_theory_and_metacircular/):
Timeless decision theory, in which the (Godelian diagonal) expected utility formula is written as follows: Argmax[A in Actions] in Sum[O in Outcomes](Utility(O)\*P(this computation yields A []-> O|rest of universe)) ... which is why TDT one-boxes on Newcomb's Problem - both your current self's physical act, and Omega's physical act in the past, are logical-causal descendants of the computation, and are recalculated accordingly inside the counterfactual. ... Timeless decision theory can state very definitely how it treats the various facts, within the interior of its expected utility calculation. It does not update any physical or logical parent of the logical output - rather, it conditions on the initial state of the computation, in order to screen off outside influences; then no further inferences about them are made.
These summaries give the strong impression that one cannot use this decision theory to figure out what to decide until one has first decomposed one's physical state into one's "computation" as distinguished from one's "initial state" and its followup data structures eventually leading to an "output." And since there are many many ways to make this decomposition, there can be many many decisions recommended by this decision theory.
The advice to "choose as though controlling the logical output of the abstract computation you implement" might have you choose as if you controlled the actions of all physical objects, if you viewed the laws of physics as your program, or choose as if you only controlled the actions of the particular physical state that you are, if every distinct physical state is a different program. |
4d2d9ab9-878e-4690-9c67-97995e4f822e | trentmkelly/LessWrong-43k | LessWrong | Inner Alignment in Salt-Starved Rats
(This post is deprecated. It has some kernels of truth but also lots of mistakes and confusions. You should instead read Incentive Learning vs Dead Sea Salt Experiment (2024), which covers many of the same topics. —Steve, 2024)
(See comment here for some corrections and retractions. —Steve, 2022)
Introduction: The Dead Sea Salt Experiment
In this 2014 paper by Mike Robinson and Kent Berridge at University of Michigan (see also this more theoretical follow-up discussion by Berridge and Peter Dayan), rats were raised in an environment where they were well-nourished, and in particular, where they were never salt-deprived—not once in their life. The rats were sometimes put into a test cage with a lever which, when it appeared, was immediately followed by a device spraying ridiculously salty water directly into their mouth. The rats were disgusted and repulsed by the extreme salt taste, and quickly learned to hate the lever—which from their perspective would seem to be somehow causing the saltwater spray. One of the rats went so far as to stay tight against the opposite wall—as far from the lever as possible!
Then the experimenters made the rats feel severely salt-deprived, by depriving them of salt. Haha, just kidding! They made the rats feel severely salt-deprived by injecting the rats with a pair of chemicals that are known to induce the sensation of severe salt-deprivation. Ah, the wonders of modern science!
...And wouldn't you know it, almost instantly upon injection, the rats changed their behavior! When shown the lever (this time without the salt-water spray), they now went right over to that lever and jumped on it and gnawed at it, obviously desperate for that super-salty water.
The end.
Aren't you impressed? Aren’t you floored? You should be!!! I don’t think any standard ML algorithm would be able to do what these rats just did!
Think about it:
* Is this Reinforcement Learning? No. RL would look like the rats randomly stumbling upon the behavior of “ni |
db4ed14f-bb45-400e-8c95-66b944478104 | trentmkelly/LessWrong-43k | LessWrong | Assigning Praise and Blame: Decoupling Epistemology and Decision Theory
Your group/company/organization performs well, doing great work and dealing with new problems efficiently. As one of its leaders, you want to understand why, so that you can make it even more successful, and maybe emulate this success in other settings.
Your group/company/organization performs badly, not delivering on what was promised and missing deadline after deadline. As one of its leaders, you want to understand why, so that you can correct its course, or at least not repeat the same mistakes in other settings.
Both cases apparently involve credit assignment: positive credit (praise) for success or negative credit (blame) for failure. And you can easily think of different ways to do so:
Heuristics for Credit Assignment
Baseline
The most straightforward approach starts with your initial prediction, and then assigns credit for deviations from it. So praise people who did better than expected and blame people who did worse than expected.
Then you remember Janice. She’s your star performer, amazing in everything she does, and you knew it from the start. So she performed according to prediction, being brilliant and reliable. Which means she doesn’t deserve any praise by this criterion.
On the other hand there is Tom. He’s quite good, but you also knew from the start he was a prickly showoff with an easily scratched ego. Still, he did his job, and when he acted like an asshole, that was within the prediction. So he doesn't deserve any blame by this criterion.
Incentive wise, this sounds like a terrible idea. If you push this credit assignment strategy, not only will you neglect the value of Janice and the cost of Tom, but you will probably drive away high-performers and attract problem-makers.
Bottleneck
Instead of starting from a baseline, let’s focus on the key bottlenecks. What would have doomed the project if not done? What ended up blocking everything and dooming the project? This focuses on the real cruxes, which is good.
Yet what about Marcel, your |
725062a9-860e-48c0-9340-6e7c89c4c253 | trentmkelly/LessWrong-43k | LessWrong | A (EtA: quick) note on terminology:
AI Alignment != AI x-safety
I think the terms "AI Alignment" and "AI existential safety" are often used interchangeably, leading the ideas to be conflated.
In practice, I think "AI Alignment" is mostly used in one of the following three ways, and should be used exclusively for Intent Alignment (with some vagueness about whose intent, e.g. designer vs. user):
1) AI Alignment = How to get AI systems to do what we want
2) AI Alignment = How to get AI systems to try to do what we want
3) AI Alignment = A rebranding of “AI (existential) safety”... A community of people trying to reduce the chance of AI leading to premature human extinction.
The problem with (1) is that it is too broad, and invites the response: "Isn't that what most/all AI research is about?"
The problem with (3) is that it suggests that (Intent) Alignment is the one-and-only way to increase AI existential safety.
Some reasons not to conflate (2) and (3):
1. The case that increasing (intent) alignment increases x-safety seems much weaker on the margin than in the limit; the main effect of a moderate increase in intent alignment might simply be a large increase in demand for AI.
2. Even perfect intent alignment doesn't necessarily result in a safe outcome; e.g. if everyone woke up 1000000x smarter tomorrow, the world might end by noon.
3. X-safety can be increased through non-technical means, e.g. governance/coordination.
4. EtA: x-safety can be increased through technical work other than alignment, e.g. assurance methods, e.g. value alignment verification.
In my experience, this sloppy use of terminology is common in this community, and leads to incorrect reasoning (if not in those using it than certainly at least sometimes in those hearing/reading it).
EtA: This Tweet and associated paper make a similar point: https://twitter.com/HeidyKhlaaf/status/1634173714055979010
|
7e31fbca-775b-4a3e-902f-dcfa10c9c96e | trentmkelly/LessWrong-43k | LessWrong | Meetup : First meetup in Innsbruck
Discussion article for the meetup : First meetup in Innsbruck
WHEN: 02 December 2012 03:00:17PM (+0100)
WHERE: Innsbruck, Austria
Let's organize the first Lesswrong meetup of Innsbruck! To be part of this historical event just click on this doodle-survey and vote for your favorite time.
You can also write a comment and suggest a place and discussion-topics if you want to.
Newbies and lurkers are welcome, obviously!
Discussion article for the meetup : First meetup in Innsbruck |
0b6b7358-ba00-49fd-ab85-68be5da2341e | trentmkelly/LessWrong-43k | LessWrong | Meetup : Less Wrong Israel Meetup (Herzliya): Social and Board Games
Discussion article for the meetup : Less Wrong Israel Meetup (Herzliya): Social and Board Games
WHEN: 04 September 2014 07:00:00PM (+0300)
WHERE: HaMada 5, Herzliya Pituach, Israel, EMC offices, floor 4
This time we're going to have a social meetup! We'll be socializing and playing games.
We'll start the meetup at 19:00 and finish at 22:00 (we may move the discussion to a nearby cafe afterwards). Feel free to come a little bit later, as there is no agenda.
We'll meet at the 4th floor of the building. Our gracious host is Yonatan Cale, and if you have trouble finding us, you can reach him at 052-5563141.
Things that might happen: - You'll trade cool ideas with cool people from the Israel LW community. - You'll discover kindred spirits who agree with you about one/two boxing. - You'll kick someone's ass (and teach them how you did it) at some awesome boardgame - You'll discover how to build a friendly AGI running on cold fusion (well probably not) - You'll discuss interesting AI topics with new friends!
Things that will happen for sure: - You'll get to hang out with awesome people and have fun!
Parking: There's a parking place under the building, and several others around us too. I'll update about free parking (I don't have a car)
Public transport: Busses: Namir, get off at צומת הרצליה/אקדיה (not הסירה), it's 5 minutes slow-walking from there. Herzelia train: ~15 minutes walking Use your GPS!
Discussion article for the meetup : Less Wrong Israel Meetup (Herzliya): Social and Board Games |
0a07f5bd-ffda-42b8-9b63-eeb4d1b8fa45 | trentmkelly/LessWrong-43k | LessWrong | A brief history of the automated corporation
Looking back from 2041
When people in the early 21st Century imagined an AI-empowered economy, they tended to project person-like AI entities doing the work. “There will be demand for agent-like systems,” they argued, “so we’ll see AI labs making agents which can then be deployed to various problems”.
We now know that that isn’t how it played out. But what led to the largely automated corporations that we see today? Let’s revisit the history:
* In the mid–late 2020s, as AI systems became reasonably reliable at many tasks, workers across the economy started consulting them more on an everyday basis
* People and companies started more collection of data showing exactly what they wanted from different tasks
* Systematizers and managers began building company workflows around the automation of tasks
* They would build systems to get things into shapes known to work especially well for automation — in many cases using off-the-shelf software solutions — and direct more of the work into these routes
* In many cases, the automation of a particular tasks involved brief invocation of specialized agent-like systems; but nothing like the long-term general purpose actors imagined in science fiction
* As best practices emerged for automating taskflows, in the early–mid 2030s we saw the start of widespread automation of automation — people used specialized AI systems (or consultants relying on such systems) to advise on which parts of the workflow should be automated and how
* For a while, human experts and managers kept a close eye on these automated loops, to catch and correct errors
* But it wasn’t long before these management processes themselves were largely automatable (or redundant), and humans just stayed in loop for the high-level decisions about how to arrange different workflows and keep them integrated with the parts still done by humans
* Although there are some great anecdotes of failures during that time, the broad trend was towards it being |
db32b739-a20f-412e-93cb-36cd43e7461f | trentmkelly/LessWrong-43k | LessWrong | Meetup : Atlanta Lesswrong: Cryonics FAQ & Signing up Party!
Discussion article for the meetup : Atlanta Lesswrong: Cryonics FAQ & Signing up Party!
WHEN: 10 May 2013 07:00:00PM (-0400)
WHERE: 2388 Lawrenceville Hwy. Apt L. Decatur, GA 30033
Transhumanism, radical life extension, and cryonics are areas that typically have a large interest intersection with rationality. Our ATLesswrong Meetup has several people who expressed a desire for a more focused session to discuss cryonics and perhaps start the paperwork process in the company of supportive friends. So this is that session! Have you been cryo-crastinating? Do you have questions that you keep meaning to research, but haven't got around to yet? Do you want hear what the process is like from people who have gone through with it? Then come to this session! Please note that no one is going to pressured to sign up! Pros and Cons will be discussed (though obviously several of us have come to the conclusion that there are net pros). This is only informational, and help with paperwork IF YOU WANT IT. If you want to come fill out paperwork "just in case" you can do so, and make the decision whether to put it in the mail later. Issues of death and finances are deeply personal, and ALL feelings will be respected. (Anyone who is not respectful to the feelings of others will be asked to leave.) Agenda: (1) Provide information about cryonics, including the organizations you can sign up with, life insurance options, and feasibility discussions. Questions and Answers with people who have already signed up. (2) Put some signatures on some papers! For those who are at that stage of the process. (3) Celebrate! There will probably be libations. I will also send out an email when I get a chance about what to do to prepare for this session, if you'd like to get the paperwork ready. Check back for the text of the email here if you are not signed up for various mailing lists.
Discussion article for the meetup : Atlanta Lesswrong: Cryonics FAQ & Signing up Party! |
e505b11a-31f5-4d92-9063-d03caef682cc | trentmkelly/LessWrong-43k | LessWrong | Internet Literacy Atrophy
It’s the holidays, which means it’s also “teach technology to your elderly relatives” season. Most of my elderly relatives are pretty smart, and were technically advanced in their day. Some were engineers or coders back when that was rare. When I was a kid they were often early adopters of tech. Nonetheless, they are now noticeably worse at technology than my friends’ 3 year old. That kid figured out how to take selfie videos on my phone after watching me do it once, and I wasn’t even deliberately demonstrating.
Meanwhile, my aunt (who was the first girl in her high school to be allowed into technical classes) got confused when attempting to use an HBOMax account I’d mostly already configured for her (I think she got confused by the new profile taste poll but I wasn’t there so I’ll never be sure). She pays a huge fee to use Go Go Grandparent instead of getting a smartphone and using Uber directly. I got excited when an uncle seemed to understand YouTube, until it was revealed that he didn’t know about channels and viewed the subscribe button as a probable trap. And of course, there was my time teaching my PhD statistician father how to use Google Sheets, which required learning a bunch of prerequisite skills he’d never needed before and I wouldn’t have had the patience to teach if it hadn’t benefited me directly.
[A friend at a party claimed Apple did a poll on this and found the subscribe button to be a common area of confusion for boomers, to the point they were thinking of changing the “subscribe” button to “follow”. And honestly, given how coy substack is around what exactly I’m subscribing to and how much it costs, this isn’t unreasonable.]
The problem isn’t that my relatives were never competent with technology, because some of them very much were at one point. I don’t think it’s a general loss of intelligence either, because they’re still very smart in other ways. Also they all seem to have kept up with shopping websites just fine. But actions I view as |
9afd050b-2912-4660-9f2a-874cee136ddc | trentmkelly/LessWrong-43k | LessWrong | AGIs as collectives
Note that I originally used the term population AGI, but changed it to collective AGI to match Bostrom's usage in Superintelligence.
I think there’s a reasonably high probability that we will end up training AGI in a multi-agent setting. But in that case, we shouldn’t just be interested in how intelligent each agent produced by this training process is, but also in the combined intellectual capabilities of a large group of agents. If those agents cooperate, they will exceed the capabilities of any one of them - and then it might be useful to think of the whole collective as one AGI. Arguably, on a large-scale view, this is how we should think of humans. Each individual human is generally intelligent in our own right. Yet from the perspective of chimpanzees, the problem was not that any single human was intelligent enough to take over the world, but rather that millions of humans underwent cultural evolution to make the human collective as a whole much more intelligent.
This idea isn’t just relevant to multi-agent training though: even if we train a single AGI, we will have strong incentives to copy it many times to get it to do more useful work. If that work involves generating new knowledge, then putting copies in contact with each other to share that knowledge would also increase efficiency. And so, one way or another, I expect that we’ll eventually end up dealing with a “collective” of AIs. Let’s call the resulting system, composed of many AIs working together, a collective AGI.
We should be clear about the differences between three possibilities which each involve multiple entities working together:
1. A single AGI composed of multiple modules, trained in an end-to-end way.
2. The Comprehensive AI Services (CAIS) model of a system of interlinked AIs which work together to complete tasks.
3. A collective AGI as described above, consisting of many individual AIs working together in comparable ways to how a collective of humans might collaborate.
This essay |
6d48e8a5-efbc-423f-8684-1aa53bb98f1a | awestover/filtering-for-misalignment | Redwood Research: Alek's Filtering Results | id: post3312
Technical Appendix: First safeguard? This sequence is written to be broadly accessible, although perhaps its focus on capable AI systems assumes familiarity with basic arguments for the importance of AI alignment . The technical appendices are an exception, targeting the technically inclined. Why do I claim that an impact measure would be "the first proposed safeguard which maybe actually stops a powerful agent with an imperfect objective from ruining things – without assuming anything about the objective"? The safeguard proposal shouldn't have to say "and here we solve this opaque, hard problem, and then it works". If we have the impact measure, we have the math, and then we have the code. So what about: Quantilizers ? This seems to be the most plausible alternative; mild optimization and impact measurement share many properties. But What happens if the agent is already powerful? A greater proportion of plans could be catastrophic, since the agent is in a better position to cause them. Where does the base distribution come from (opaque, hard problem?), and how do we know it's safe to sample from? In the linked paper, Jessica Taylor suggests the idea of learning a human distribution over actions – how robustly would we need to learn this distribution? How numerous are catastrophic plans, and what is a catastrophe, defined without reference to our values in particular? (That definition requires understanding impact!) Value learning ? But We only want this if our (human) values are learned! Value learning is impossible without assumptions , and getting good enough assumptions could be really hard . If we don't know if we can get value learning / reward specification right, we'd like safeguards which don't fail because value learning goes wrong. The point of a safeguard is that it can catch you if the main thing falls through; if the safeguard fails because the main thing does, that's pointless. Corrigibility ? At present, I'm excited about this property because I suspect it has a simple core principle. But Even if the system is responsive to correction (and non-manipulative, and whatever other properties we associate with corrigibility), what if we become unable to correct it as a result of early actions (if the agent "moves too quickly", so to speak)? Paul Christiano's take on corrigibility is much broader and an exception to this critique. What is the core principle? Notes The three sections of this sequence will respectively answer three questions: Why do we think some things are big deals? Why are capable goal-directed AIs incentivized to catastrophically affect us by default? How might we build agents without these incentives? The first part of this sequence focuses on foundational concepts crucial for understanding the deeper nature of impact. We will not yet be discussing what to implement. I strongly encourage completing the exercises. At times you shall be given a time limit; it’s important to learn not only to reason correctly, but with speed. The best way to use this book is NOT to simply read it or study it, but to read a question and STOP. Even close the book. Even put it away and THINK about the question. Only after you have formed a reasoned opinion should you read the solution. Why torture yourself thinking? Why jog? Why do push-ups? If you are given a hammer with which to drive nails at the age of three you may think to yourself, "OK, nice." But if you are given a hard rock with which to drive nails at the age of three, and at the age of four you are given a hammer, you think to yourself, "What a marvellous invention!" You see, you can't really appreciate the solution until you first appreciate the problem. ~ Thinking Physics My paperclip-Balrog illustration is metaphorical: a good impact measure would hold steadfast against the daunting challenge of formally asking for the right thing from a powerful agent. The illustration does not represent an internal conflict within that agent. As water flows downhill, an impact-penalizing Frank prefers low-impact plans. The drawing is based on gonzalokenny's amazing work . Some of you may have a different conception of impact; I ask that you grasp the thing that I’m pointing to. In doing so, you might come to see your mental algorithm is the same. Ask not “is this what I initially had in mind?”, but rather “does this make sense as a thing-to-call-'impact'?”. H/T Rohin Shah for suggesting the three key properties. Alison Bowden contributed several small drawings and enormous help with earlier drafts. |
76993d9b-98c5-4f2d-8b0e-7bc7af1263ce | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | List of good AI safety project ideas?
Can we compile a list of good project ideas related to AI safety that people can work on? There are occasions at work when I have the opportunity to propose interesting project ideas for potential funding, and it would be really useful if there was somewhere I could look for projects that people here would really like someone to work on, even if they themselves don't have the time or resources to do so. I also keep meeting people who are searching for useful alignment-related projects they can work on for school, work, or as personal projects, and I think a list of project ideas might be helpful for them as well.
I'm particularly interested in project ideas that are currently not being worked on (to your knowledge) but where it would be great if someone would take up that project. Or alternatively, project ideas that are currently being worked on but where there are variations on those ideas that nobody has yet attempted but someone should.
Occasionally someone will post an idea or set of ideas on the Alignment Forum, for example Ajeya Cotra's ["sandwiching" idea](https://www.alignmentforum.org/posts/PZtsoaoSLpKjjbMqM/the-case-for-aligning-narrowly-superhuman-models#Potential_near_future_projects___sandwiching_) or the recent [list of ideas from Stuart Armstrong and Owain Evans](https://www.alignmentforum.org/posts/f69LK7CndhSNA7oPn/ai-safety-research-project-ideas). I also sometimes come across ideas mentioned towards the end of a paper or buried somewhere in a research agenda. But I think having a larger list somewhere could be really useful.
(Note: I am *not* looking for lists of open problems, challenges, or very general research directions. I'm looking for suggestions that at least point towards a concrete project idea, and where an individual or small team might be able to produce useful results given current technology and with sufficient time and resources.)
Please post ideas or links / references to published ideas in the comments, if you know of any. Ideas mentioned as part of a larger post or paper would count, but please point to the section where the idea is mentioned.
If I get enough links or references maybe I'll try to compile a list that others can use. |
a95ca5c6-d630-480f-a5a8-5e12d62c9252 | trentmkelly/LessWrong-43k | LessWrong | AI Safety Needs Great Product Builders
In his AI Safety Needs Great Engineers post, Andy Jones explains how software engineers can reduce the risks of unfriendly artificial intelligence. Even without deep ML knowledge, these developers can work effectively on the challenges involved in building and understanding large language models.
I would broaden the claim: AI safety doesn’t need only great engineers – it needs great product builders in general.
This post will describe why, list some concrete projects for a few different roles, and show how they contribute to AI going better for everyone.
Audience
This post is aimed at anyone who has been involved with building software products: web developers, product managers, designers, founders, devops, generalist software engineers, … I’ll call these “product builders”.
Non-technical roles (e.g. operations, HR, finance) do exist in many organisations focussed on AI safety, but this post isn’t aimed at them.
But I thought I would need a PhD!
In the past, most technical AI safety work was done in academia or in research labs. This is changing because – among other things – we now have concrete ideas for how to construct AI in a safer manner.
However, it’s not enough for us to merely have ideas of what to build. We need teams of people to partner with these researchers and build real systems, in order to:
* Test whether they work in the real world.
* Demonstrate that they have the nice safety features we’re looking for.
* Gather empirical data for future research.
This strand of AI safety work looks much more like product development, which is why you – as a product builder – can have a direct impact today.
Example projects, and why they’re important
To prove there are tangible ways that product builders can contribute to AI safety, I’ll give some current examples of work we’re doing at Ought.
For software engineers
In addition to working on our user-facing app, Elicit, we recently open-sourced our Interactive Composition Explorer (ICE).
ICE is a |
64340418-eefb-48f1-9259-b9329ec1da1e | StampyAI/alignment-research-dataset/lesswrong | LessWrong | Funding Good Research
Series: [How to Purchase AI Risk Reduction](/r/discussion/lw/cs6/how_to_purchase_ai_risk_reduction/)
I recently explained that one major project undergoing cost-benefit analysis at the Singularity Institute is that of a [scholarly AI risk wiki](/lw/cnj/a_scholarly_ai_risk_wiki/). The proposal is exciting to many, but as Kaj Sotala points out:
>
> This idea sounds promising, but I find it hard to say anything about "should this be funded" without knowing what the alternative uses for the money are. Almost any use of money can be made to sound attractive with some effort, but the crucial question in budgeting is not "would this be useful" but "would this be the most useful thing".
>
>
>
Indeed. So here is another thing that donations to SI could purchase: good research papers by skilled academics.
Our recent grant of $20,000 to [Rachael Briggs](http://www.rachaelbriggs.net/) (for an introductory paper on [TDT](http://wiki.lesswrong.com/wiki/Timeless_decision_theory)) provides an example of how this works:
1. SI thinks of a paper it wants to exist but doesn't have the resources to write itself (e.g. a clearer presentation of TDT).
2. SI looks for a few productive academics well-suited to write the paper we have in mind, and approaches them directly with the grant proposal. (Briggs is an excellent choice for the TDT paper because she is a good explainer and has had two of her past decision theory papers selected as among the 10 best papers of the year by [The Philosopher's Annual](http://www.philosophersannual.org/).)
3. Hopefully, one of these academics says "yes." We award them the grant in return for a certain kind of paper published in one of a pre-specified set of journals. (In the case of the TDT grant to Rachael Briggs, we specified that the final paper must be published in one of the following journals: *Philosopher's Imprint*, *Philosophy and Phenomenological Research*, *Philosophical Quarterly*, *Philosophical Studies*, *Erkenntnis*, *Theoria*, *Australasian Journal of Philosophy*, *Nous*, *The Philosophical Review*, or *Theory and Decision*.)
4. SI gives regular feedback on outline drafts and article drafts prepared by the article author.
5. Paper gets submitted, revised, and published!
For example, SI could award grants for the following papers:
* "**Objections to CEV**," by somebody like [David Sobel](http://www.unl.edu/philosophy/people/faculty/sobel/sobel.shtml) (his "[Full Information Accounts of Well-Being](http://commonsenseatheism.com/wp-content/uploads/2011/03/Sobel-Full-Information-Accounts-of-Well-Being.pdf)" remains the most significant unanswered attack on ideal-preference theories like CEV).
* "**Counterfactual Mugging**," by somebody like [Rachael Briggs](http://www.rachaelbriggs.net/) ([here](/lw/3l/counterfactual_mugging/) is the original post by Vladimir Nesov).
* "**CEV as a Computational Meta-Ethics,**" by somebody like [Gert-Jan Lokhorst](http://homepages.ipact.nl/~lokhorst/) (see his paper "[Computational Metaethics](http://commonsenseatheism.com/wp-content/uploads/2011/03/Lokhorst-Computational-meta-ethics-toward-the-meta-ethical-robot.pdf)").
* "**Non-Bayesian Decision Theory and Normative Uncertainty,**" by somebody like [Martin Peterson](http://www.martinpeterson.org/) (the problem of normative uncertainty is a serious one, and [Peterson's approach](http://www.amazon.com/Non-Bayesian-Decision-Theory-Beliefs-Desires/dp/9048179572/) is a different line of approach than the one pursued by [Nick Bostrom](http://www.overcomingbias.com/2009/01/moral-uncertainty-towards-a-solution.html), [Toby Ord](http://www.amirrorclear.net/academic/), and [Will Crouch](http://www.practicalethics.ox.ac.uk/staff/staff/research_associates/will_crouch), and also different from the one pursued by [Andrew Sepielli](http://www.fil.lu.se/files/conference117.pdf)).
* "**Methods for Long-Term Technological Forecasting,**" by somebody like [Bela Nagy](http://www.santafe.edu/about/people/profile/B%C3%A9la%20Nagy) (Nagy is the lead author on [one of the best papers in the field](http://tuvalu.santafe.edu/~bn/workingpapers/NagyFarmerTrancikBui.pdf))
* "**Convergence to Rational Economic Agency,**" by somebody like [Steve Omohundro](http://steveomohundro.com/) ([Omohundro's 2007 paper](http://selfawaresystems.files.wordpress.com/2008/01/nature_of_self_improving_ai.pdf) argues that advanced agents will converge toward the rational economic model of decision-making, if true this would make it easier to predict the convergent instrumental goals of advanced AIs, but his argument leaves much to be desired in persuasiveness as it is currently formulated).
* "**Value Learning,**" by somebody like [Bill Hibbard](http://www.ssec.wisc.edu/~billh/homepage1.html) ([Dewey's 2011 paper](http://www.danieldewey.net/learning-what-to-value.pdf) and [Hibbard's 2012 paper](http://arxiv.org/pdf/1111.3934v1.pdf) make interesting advances on this topic, but there is much more work to be done).
* "**Learning Preferences from Human Behavior,**" by somebody like [Thomas Nielsen](http://www.informatik.uni-trier.de/~ley/db/indices/a-tree/n/Nielsen:Thomas_D=.html) ([Nielsen's 2004 paper with Finn Jensen](http://commonsenseatheism.com/wp-content/uploads/2011/11/Muehlhauser-Helm-The-Singularity-and-Machine-Ethics-draft.pdf) described the first computationally tractable algorithms capable of learning a decision maker’s utility function from potentially inconsistent behavior. Their solution was to interpret inconsistent choices as random deviations from an underlying “true” utility function. But the data from neuroeconomics [suggest](/lw/9jh/the_humans_hidden_utility_function_maybe/) a different solution: interpret inconsistent choices as deviations from an underlying “true” utility function that are produced by non-model-based valuation systems in the brain, and use the latest neuroscientific research to predict when and to what extent model-based choices are being “overruled” by the non-model-based valuation systems).
(These are only examples. I don't necessarily think these *particular* papers would be good investments.) |
0f48f390-cdb5-4047-bb29-24dedac8086a | trentmkelly/LessWrong-43k | LessWrong | What is the name of this fallacy?
I failed to identify whether this is a well-known fallacy, I would appreciate it if someone tells me what this is called.
The fallacy normally goes like this:
> I see you are very happy to criticize the government! Now go back to your place using the road that the government built for you!
>
> So you say capitalism is horrible and must be destroyed - on the iPhone made by a corporation.
>
> You are being an hypocrete criticizing public education because you went to a public school and did your studies thanks to the State, that financed your education
In all cases, the fallacy is assuming that if no public entity had created the environment allowing an individual to do something (or benefit from some advantage), no one else would have.
If there is no name for this fallacy I would suggest calling it the Christian bridge fallacy. I heard this example from Sam Harris. I don't remember his literal words but it goes like this;
> Some historians argue that we must thank the Church for the bridges built in Europe during the Middle Ages. However, this is wrong: the Church built those bridges basically because they were the only ones around with power; if they hadn't done it, someone else would have done it.
In my examples, the same thing applies. I might have been able to study in a public school thanks to the government, but if that weren't the case, I would have probably studied anyway, only in a different way.
Please notice one important thing too: There might be some cases where this sort of argument is not a fallacy but a real objection. |
29aef355-4078-457a-9fbe-2c63184b1a7f | trentmkelly/LessWrong-43k | LessWrong | I think I came up with a good utility function for AI that seems too obvious. Can you people poke holes in it?
Basically, the AI does the following:
Create a list of possible futures that it could cause.
For each person and future at the time of the AI's activation:
1. Simulate convincing that person that the future is going to happen.
2. If the person would try to help the AI, add 1 to the utility of that future, and if the person would try to stop the AI, subtract 1 from the utility of that future.
Cause the future with the highest utility |
eb30ecb7-3a10-4caf-885e-df68007e9536 | trentmkelly/LessWrong-43k | LessWrong | Notes on Life
Whether AI is a life-form or not is a debate full of speculations. But it may occur not that tricky after all. Very much depends on how you define life in the first place.
You can approach the definition from different perspectives. One would be from the energy perspective — going against entropy growth is an indication of being alive.
Then the other potential direction is the ability to replicate. If you take this criteria alone, then viruses, memes, and information-based entities are valid candidates for life-forms. They are passive, though, and require some medium to live in, nevertheless, I’m inclined to call that life too. I think, they label this particular case a quasi-life.
Ability to replicate is an interesting criteria, though. Is the last human on Earth alive or not? On one hand it is, as it’s no different from the same human on Earth full of other people. But on the other hand it has no ability to replicate, therefore, it’s not. In this sense human that requires other humans (or food, or some specific environment) to live is not much different from the viruses that require other life-forms to parasite on, or memes that require some other intelligent life-forms to keep them (memes) alive. That blurs the line between quasi-life and “real-life”, so I’d say phenomena of life is more fundamental than the difference between life-forms.
Clearly there's much more possible criteria and definitions, but what seems to be common between the life forms is the boundary between the life-form instance and the external world. If you pick arbitrary point in space, you can tell if it belongs to the life-form or dead space outside. Effectively meaning that life is a local disruption in the non-life space. What lies within this boundary is a body of this life-form instance. For information based life-forms it’s trickier, but just as with viruses, a piece of a physical world with information encoded in it that is potentially readable/executable by something would technica |
577b432a-35ce-47db-9cc8-73e2ed508fe7 | StampyAI/alignment-research-dataset/eaforum | Effective Altruism Forum | [Linkpost] Michael Nielsen remarks on 'Oppenheimer'
This is a linkpost to a recent blogpost from [Michael Nielsen](https://michaelnielsen.org/), who has previously written on [EA](https://michaelnotebook.com/eanotes/) among many other topics. This blogpost is adapted from a talk Nielsen gave to an audience working on AI before a screening of *Oppenheimer*. I think the full post is worth a read, but I've pulled out some quotes I find especially interesting (bolding my own)
> I was at a party recently, and happened to meet a senior person at a well-known AI startup in the Bay Area. They volunteered that they thought "humanity had about a 50% chance of extinction" caused by artificial intelligence. I asked why they were working at an AI startup if they believed that to be true. They told me that while they thought it was true, "**in the meantime I get to have a nice house and car**".
>
>
> [...] I often meet people who claim to sincerely believe (or at least seriously worry) that AI may cause significant damage to humanity. And yet they are also working on it, justifying it in ways that sometimes seem sincerely thought out, but which **all-too-often seem self-serving or self-deceiving.**
>
>
> Part of what makes the Manhattan Project interesting is that we can chart the arcs of moral thinking of multiple participants [...] Here are four caricatures:
>
> * Klaus Fuchs and Ted Hall were two Manhattan Project physicists who took it upon themselves to commit espionage, communicating the secret of the bomb to the Soviet Union. It's difficult to know for sure, but **both seem to have been deeply morally engaged and trying to do the right thing, willing to risk their lives**; they also made, I strongly believe, a terrible error of judgment. I take it as a warning that **caring and courage and imagination are not enough**; they can, in fact, lead to very bad outcomes.
> * Robert Wilson, the physicist who recruited Richard Feynman to the project. Wilson had thought deeply about Nazi Germany, and the capabilities of German physics and industry, and made a principled commitment to the project on that basis. He half-heartedly considered leaving when Germany surrendered, but opted to continue until the bombings in Japan. He later regretted that choice; immediately after the Trinity Test he was disconsolate, telling an exuberant Feynman: "It's a terrible thing that we made".
> * Oppenheimer, who I believe was motivated in part by a genuine fear of the Nazis, but also in part by personal ambition and a desire for "success". It's interesting to ponder his statements after the War: while he seems to have genuinely felt a strong need to work on the bomb in the face of the Nazi threat, his comments about continuing to work up to the bombing of Hiroshima and Nagasaki contain many strained self-exculpatory statements about how you have to work on it as a scientist, that the technical problem is too sweet. It smells, to me, of someone looking for self-justification.
> * Joseph Rotblat, the one physicist who actually left the project after it became clear the Nazis were not going to make an atomic bomb. He was threatened by the head of Los Alamos security, and falsely accused of having met with Soviet agents. In leaving he was turning his back on his most important professional peers at a crucial time in his career. **Doing so must have required tremendous courage and moral imagination**. Part of what makes the choice intriguing is that **he himself didn't think it would make any difference to the success of the project. I know I personally find it tempting to think about such choices in abstract systems terms: "I, individually, can't change systems outcomes by refusing to participate ['it's inevitable!'], therefore it's okay to participate"**. And yet while that view seems reasonable, Rotblat's example shows it is incorrect. His private moral thinking, which seemed of small import initially, set a chain of thought in motion that eventually led to Rotblat founding the Pugwash Conferences, a major forum for nuclear arms control, one that both Robert McNamara and Mikhail Gorbachev identified as helping reduce the threat of nuclear weapons. Rotblat ultimately received the Nobel Peace Prize. **Moral choices sometimes matter not only for their immediate impact, but because they are seeds for downstream changes in behavior that cannot initially be anticipated.**
> |
52969161-328a-4be3-b4fa-37a0e37feb03 | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | Anthropics over-simplified: it's about priors, not updates
.mjx-chtml {display: inline-block; line-height: 0; text-indent: 0; text-align: left; text-transform: none; font-style: normal; font-weight: normal; font-size: 100%; font-size-adjust: none; letter-spacing: normal; word-wrap: normal; word-spacing: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; margin: 0; padding: 1px 0}
.MJXc-display {display: block; text-align: center; margin: 1em 0; padding: 0}
.mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex] {display: inline-table}
.mjx-full-width {text-align: center; display: table-cell!important; width: 10000em}
.mjx-math {display: inline-block; border-collapse: separate; border-spacing: 0}
.mjx-math \* {display: inline-block; -webkit-box-sizing: content-box!important; -moz-box-sizing: content-box!important; box-sizing: content-box!important; text-align: left}
.mjx-numerator {display: block; text-align: center}
.mjx-denominator {display: block; text-align: center}
.MJXc-stacked {height: 0; position: relative}
.MJXc-stacked > \* {position: absolute}
.MJXc-bevelled > \* {display: inline-block}
.mjx-stack {display: inline-block}
.mjx-op {display: block}
.mjx-under {display: table-cell}
.mjx-over {display: block}
.mjx-over > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-under > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-stack > .mjx-sup {display: block}
.mjx-stack > .mjx-sub {display: block}
.mjx-prestack > .mjx-presup {display: block}
.mjx-prestack > .mjx-presub {display: block}
.mjx-delim-h > .mjx-char {display: inline-block}
.mjx-surd {vertical-align: top}
.mjx-mphantom \* {visibility: hidden}
.mjx-merror {background-color: #FFFF88; color: #CC0000; border: 1px solid #CC0000; padding: 2px 3px; font-style: normal; font-size: 90%}
.mjx-annotation-xml {line-height: normal}
.mjx-menclose > svg {fill: none; stroke: currentColor}
.mjx-mtr {display: table-row}
.mjx-mlabeledtr {display: table-row}
.mjx-mtd {display: table-cell; text-align: center}
.mjx-label {display: table-row}
.mjx-box {display: inline-block}
.mjx-block {display: block}
.mjx-span {display: inline}
.mjx-char {display: block; white-space: pre}
.mjx-itable {display: inline-table; width: auto}
.mjx-row {display: table-row}
.mjx-cell {display: table-cell}
.mjx-table {display: table; width: 100%}
.mjx-line {display: block; height: 0}
.mjx-strut {width: 0; padding-top: 1em}
.mjx-vsize {width: 0}
.MJXc-space1 {margin-left: .167em}
.MJXc-space2 {margin-left: .222em}
.MJXc-space3 {margin-left: .278em}
.mjx-test.mjx-test-display {display: table!important}
.mjx-test.mjx-test-inline {display: inline!important; margin-right: -1px}
.mjx-test.mjx-test-default {display: block!important; clear: both}
.mjx-ex-box {display: inline-block!important; position: absolute; overflow: hidden; min-height: 0; max-height: none; padding: 0; border: 0; margin: 0; width: 1px; height: 60ex}
.mjx-test-inline .mjx-left-box {display: inline-block; width: 0; float: left}
.mjx-test-inline .mjx-right-box {display: inline-block; width: 0; float: right}
.mjx-test-display .mjx-right-box {display: table-cell!important; width: 10000em!important; min-width: 0; max-width: none; padding: 0; border: 0; margin: 0}
.MJXc-TeX-unknown-R {font-family: monospace; font-style: normal; font-weight: normal}
.MJXc-TeX-unknown-I {font-family: monospace; font-style: italic; font-weight: normal}
.MJXc-TeX-unknown-B {font-family: monospace; font-style: normal; font-weight: bold}
.MJXc-TeX-unknown-BI {font-family: monospace; font-style: italic; font-weight: bold}
.MJXc-TeX-ams-R {font-family: MJXc-TeX-ams-R,MJXc-TeX-ams-Rw}
.MJXc-TeX-cal-B {font-family: MJXc-TeX-cal-B,MJXc-TeX-cal-Bx,MJXc-TeX-cal-Bw}
.MJXc-TeX-frak-R {font-family: MJXc-TeX-frak-R,MJXc-TeX-frak-Rw}
.MJXc-TeX-frak-B {font-family: MJXc-TeX-frak-B,MJXc-TeX-frak-Bx,MJXc-TeX-frak-Bw}
.MJXc-TeX-math-BI {font-family: MJXc-TeX-math-BI,MJXc-TeX-math-BIx,MJXc-TeX-math-BIw}
.MJXc-TeX-sans-R {font-family: MJXc-TeX-sans-R,MJXc-TeX-sans-Rw}
.MJXc-TeX-sans-B {font-family: MJXc-TeX-sans-B,MJXc-TeX-sans-Bx,MJXc-TeX-sans-Bw}
.MJXc-TeX-sans-I {font-family: MJXc-TeX-sans-I,MJXc-TeX-sans-Ix,MJXc-TeX-sans-Iw}
.MJXc-TeX-script-R {font-family: MJXc-TeX-script-R,MJXc-TeX-script-Rw}
.MJXc-TeX-type-R {font-family: MJXc-TeX-type-R,MJXc-TeX-type-Rw}
.MJXc-TeX-cal-R {font-family: MJXc-TeX-cal-R,MJXc-TeX-cal-Rw}
.MJXc-TeX-main-B {font-family: MJXc-TeX-main-B,MJXc-TeX-main-Bx,MJXc-TeX-main-Bw}
.MJXc-TeX-main-I {font-family: MJXc-TeX-main-I,MJXc-TeX-main-Ix,MJXc-TeX-main-Iw}
.MJXc-TeX-main-R {font-family: MJXc-TeX-main-R,MJXc-TeX-main-Rw}
.MJXc-TeX-math-I {font-family: MJXc-TeX-math-I,MJXc-TeX-math-Ix,MJXc-TeX-math-Iw}
.MJXc-TeX-size1-R {font-family: MJXc-TeX-size1-R,MJXc-TeX-size1-Rw}
.MJXc-TeX-size2-R {font-family: MJXc-TeX-size2-R,MJXc-TeX-size2-Rw}
.MJXc-TeX-size3-R {font-family: MJXc-TeX-size3-R,MJXc-TeX-size3-Rw}
.MJXc-TeX-size4-R {font-family: MJXc-TeX-size4-R,MJXc-TeX-size4-Rw}
.MJXc-TeX-vec-R {font-family: MJXc-TeX-vec-R,MJXc-TeX-vec-Rw}
.MJXc-TeX-vec-B {font-family: MJXc-TeX-vec-B,MJXc-TeX-vec-Bx,MJXc-TeX-vec-Bw}
@font-face {font-family: MJXc-TeX-ams-R; src: local('MathJax\_AMS'), local('MathJax\_AMS-Regular')}
@font-face {font-family: MJXc-TeX-ams-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_AMS-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_AMS-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_AMS-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-B; src: local('MathJax\_Caligraphic Bold'), local('MathJax\_Caligraphic-Bold')}
@font-face {font-family: MJXc-TeX-cal-Bx; src: local('MathJax\_Caligraphic'); font-weight: bold}
@font-face {font-family: MJXc-TeX-cal-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-R; src: local('MathJax\_Fraktur'), local('MathJax\_Fraktur-Regular')}
@font-face {font-family: MJXc-TeX-frak-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-B; src: local('MathJax\_Fraktur Bold'), local('MathJax\_Fraktur-Bold')}
@font-face {font-family: MJXc-TeX-frak-Bx; src: local('MathJax\_Fraktur'); font-weight: bold}
@font-face {font-family: MJXc-TeX-frak-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-BI; src: local('MathJax\_Math BoldItalic'), local('MathJax\_Math-BoldItalic')}
@font-face {font-family: MJXc-TeX-math-BIx; src: local('MathJax\_Math'); font-weight: bold; font-style: italic}
@font-face {font-family: MJXc-TeX-math-BIw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-BoldItalic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-BoldItalic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-BoldItalic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-R; src: local('MathJax\_SansSerif'), local('MathJax\_SansSerif-Regular')}
@font-face {font-family: MJXc-TeX-sans-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-B; src: local('MathJax\_SansSerif Bold'), local('MathJax\_SansSerif-Bold')}
@font-face {font-family: MJXc-TeX-sans-Bx; src: local('MathJax\_SansSerif'); font-weight: bold}
@font-face {font-family: MJXc-TeX-sans-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-I; src: local('MathJax\_SansSerif Italic'), local('MathJax\_SansSerif-Italic')}
@font-face {font-family: MJXc-TeX-sans-Ix; src: local('MathJax\_SansSerif'); font-style: italic}
@font-face {font-family: MJXc-TeX-sans-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-script-R; src: local('MathJax\_Script'), local('MathJax\_Script-Regular')}
@font-face {font-family: MJXc-TeX-script-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Script-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Script-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Script-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-type-R; src: local('MathJax\_Typewriter'), local('MathJax\_Typewriter-Regular')}
@font-face {font-family: MJXc-TeX-type-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Typewriter-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Typewriter-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Typewriter-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-R; src: local('MathJax\_Caligraphic'), local('MathJax\_Caligraphic-Regular')}
@font-face {font-family: MJXc-TeX-cal-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-B; src: local('MathJax\_Main Bold'), local('MathJax\_Main-Bold')}
@font-face {font-family: MJXc-TeX-main-Bx; src: local('MathJax\_Main'); font-weight: bold}
@font-face {font-family: MJXc-TeX-main-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-I; src: local('MathJax\_Main Italic'), local('MathJax\_Main-Italic')}
@font-face {font-family: MJXc-TeX-main-Ix; src: local('MathJax\_Main'); font-style: italic}
@font-face {font-family: MJXc-TeX-main-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-R; src: local('MathJax\_Main'), local('MathJax\_Main-Regular')}
@font-face {font-family: MJXc-TeX-main-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-I; src: local('MathJax\_Math Italic'), local('MathJax\_Math-Italic')}
@font-face {font-family: MJXc-TeX-math-Ix; src: local('MathJax\_Math'); font-style: italic}
@font-face {font-family: MJXc-TeX-math-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size1-R; src: local('MathJax\_Size1'), local('MathJax\_Size1-Regular')}
@font-face {font-family: MJXc-TeX-size1-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size1-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size1-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size1-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size2-R; src: local('MathJax\_Size2'), local('MathJax\_Size2-Regular')}
@font-face {font-family: MJXc-TeX-size2-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size2-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size2-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size2-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size3-R; src: local('MathJax\_Size3'), local('MathJax\_Size3-Regular')}
@font-face {font-family: MJXc-TeX-size3-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size3-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size3-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size3-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size4-R; src: local('MathJax\_Size4'), local('MathJax\_Size4-Regular')}
@font-face {font-family: MJXc-TeX-size4-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size4-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size4-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size4-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-R; src: local('MathJax\_Vector'), local('MathJax\_Vector-Regular')}
@font-face {font-family: MJXc-TeX-vec-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-B; src: local('MathJax\_Vector Bold'), local('MathJax\_Vector-Bold')}
@font-face {font-family: MJXc-TeX-vec-Bx; src: local('MathJax\_Vector'); font-weight: bold}
@font-face {font-family: MJXc-TeX-vec-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Bold.otf') format('opentype')}
I've argued that [anthropic reasoning isn't magic](https://www.lesswrong.com/posts/4ZRDXv7nffodjv477/anthropic-reasoning-isn-t-magic), applied [anthropic reasoning to the Fermi question](https://www.lesswrong.com/posts/M9sb3dJNXCngixWvy/anthropics-and-fermi), claimed that [different anthropic probabilities answer different questions](https://www.lesswrong.com/posts/nxRjC93AmsFkfDYQj/anthropic-probabilities-answering-different-questions), and concluded that [anthropics is pretty normal](https://www.lesswrong.com/posts/uAqs5Q3aGEen3nKeX/anthropics-is-pretty-normal).
But all those posts were long and somewhat technical, and needed some familiarity with anthropic reasoning in order to be applied. So here I'll list what people unfamiliar with anthropic reasoning can do to add it simply[[1]](#fn-F5K2FcNZ3Tq8M483s-1) and easily to their papers/blog posts/discussions:
1. Anthropics is about priors, not updates; updates function the same way for all anthropic probabilities.
2. If two theories predict the same population, there is no anthropic effect between them.
Updating on safety
------------------
Suppose you go into hiding in a bunker in 1956. You're not sure if the cold war is intrinsically stable or unstable. Stable predicts a 25% chance of nuclear war; unstable predicts a 75% chance.
You emerge much older in 2020, and notice there has not been a nuclear war. Then, whatever anthropic probability theory you use, you update the ratio
P(stable):P(unstable) by 75:25=3:1.
Population balancing
--------------------
Suppose you have two theories to explain the Fermi paradox:
* Theory 1 is that life can only evolve in very rare conditions, so Earth has the only life in the reachable universe.
* Theory 2 is that there is some disaster that regularly obliterates pre-life conditions, so Earth has the only life in the reachable universe.
Since the total population predicted by these two theories is the same, there is no anthropic update between them[[2]](#fn-F5K2FcNZ3Tq8M483s-2).
---
1. These points are a bit over-simplified, but are suitable for most likely scenarios. [↩︎](#fnref-F5K2FcNZ3Tq8M483s-1)
2. If you use a reference class that doesn't include certain entities - maybe you don't include pre-mammals or beings without central nervous systems - then you only need to compare the population that is in your reference class. [↩︎](#fnref-F5K2FcNZ3Tq8M483s-2) |
67dc2c05-0939-4b4b-a544-41a62c802885 | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | Conclusion to the sequence on value learning
*This post summarizes the sequence on value learning. While it doesn’t introduce any new ideas, it does shed light on which parts I would emphasize most, and the takeaways I hope that readers get. I make several strong claims here; interpret these as my [impressions, not my beliefs](http://www.overcomingbias.com/2008/04/naming-beliefs.html). I would guess many researchers disagree with the (strength of the) claims, though I do not know what their arguments would be.*
Over the last three months we’ve covered a lot of ground. It’s easy to lose sight of the overall picture over such a long period of time, so let's do a brief recap.
### The “obvious” approach
Here is an argument for the importance of AI safety:
* Any agent that is much more intelligent than us [should not be exploitable](https://arbital.com/p/optimized_agent_appears_coherent/) by us, since if we could find some way to exploit the agent, the agent could also find the exploit and patch it.
* Anything that is not exploitable must be an [expected utility maximizer](https://arbital.com/p/expected_utility_formalism/?l=7hh); since we cannot exploit a superintelligent AI, it must look like an expected utility maximizer to us.
* Due to [Goodhart’s Law](https://www.lesswrong.com/posts/EbFABnst8LsidYs5Y/goodhart-taxonomy), even “slightly wrong” utility functions can lead to catastrophic outcomes when maximized.
* Our utility function is complex and [fragile](https://www.lesswrong.com/posts/GNnHHmm8EzePmKzPk/value-is-fragile), so getting the “right” utility function is difficult.
This argument implies that by the time we have a superintelligent AI system, there is only one part of that system that could still have been influenced by us: the utility function. Every other feature of the AI system is fixed by math. As a result, we must *necessarily* solve AI alignment by influencing the utility function.
So of course, the natural approach is to [get the right utility function](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/5eX8ko7GCxwR5N9mN), or at least an [adequate](https://www.alignmentforum.org/posts/Y2LhX3925RodndwpC/resolving-human-values-completely-and-adequately) one, and have our AI system optimize that utility function. Besides [fragility of value](https://www.lesswrong.com/posts/GNnHHmm8EzePmKzPk/value-is-fragile), which you might hope that machine learning could overcome, the big challenge is that even if you assume [full access to the entire human policy](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/h9DesGT3WT9u2k7Hr), we [cannot infer their values](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/ANupXf8XfZo2EJxGv) without making an assumption about how their preferences relate to their behavior. In addition, any [misspecification](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/gnvrixhDfG7S2TpNL) can lead to [bad inferences](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/cnC2RMWEGiGpJv8go). And finally the entire project of having a single utility function that captures optimal behavior in all possible environments seems quite hard to do -- it seems necessary to have some sort of [feedback from humans](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/4783ufKpx8xvLMPc6), or you end up extrapolating in some strange way that is not necessarily what we “would have” wanted.
So does this mean we’re doomed? Well, there are still some [potential avenues](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/EhNCnCkmu7MwrQ7yz) for rescuing ambitious value learning, though they do look quite difficult to me. But I think we should actually question the assumptions underlying our original argument.
### Problems with the standard argument
Consider the calculator. From the perspective of someone before the time of calculators, this device would look quite intelligent -- just look at the speed with which it can do arithmetic! Nonetheless, we can all agree that a standard calculator is not dangerous.
It also seems strange to ascribe goals to the calculator -- while this is not *wrong* per se, we certainly have better ways of predicting what a calculator will and will not do than by modelling it as an expected utility maximizer. If you model a calculator as aiming to achieve the goal of “give accurate math answers”, problems arise: what if I take a hammer to the calculator and then try to ask it 5 + 3? The utility maximizer model here would say that it answers 8, whereas with our understanding of how calculators work we know it probably won’t give any answer at all. Utility maximization with a simple utility function is only a good model for the calculator within a restricted set of environmental circumstances and a restricted action space. (For example, we don’t model the calculator as having access to the action, “build armor that can protect against hammer attacks”, because otherwise utility maximization would predict it takes that action.)
Of course, it may be that something that is generally superintelligent will work in as broad a set of circumstances as we do, and will have as wide an action space as we do, and must still look to us like an [expected utility maximizer](https://arbital.com/p/expected_utility_formalism/?l=7hh) since [otherwise we could Dutch book it](https://arbital.com/p/optimized_agent_appears_coherent/). However, if you take such a broad view, then it turns out that [all behavior looks coherent](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/NxF5G6CJiof6cemTw). There’s no *mathematical* reason that an intelligent agent must have catastrophic behavior, since *any* behavior that you observe is consistent with the maximization of some utility function.
To be clear, while I agree with every statement in [Optimized agent appears coherent](https://arbital.com/p/optimized_agent_appears_coherent/), I am making the strong claim that these statements are *vacuous* and by themselves tell us nothing about the systems that we will actually build. Typically, I do not flat out disagree with a common argument. I usually think that the argument is important and forms a piece of the picture, but that there are other arguments that push in other directions that might be more important. That’s not the case here: I am claiming that the argument that “superintelligent agents must be expected utility maximizers by virtue of coherence arguments” provides *no* useful information, with almost the force of a theorem. My uncertainty here is almost entirely caused by the fact that other smart people believe that this argument is important and relevant.
I am *not* claiming that we don’t need to worry about AI safety since AIs won’t be expected utility maximizers. First of all, you *can* model them as expected utility maximizers, it’s just not useful. Second, if we build an AI system whose internal reasoning consisted of maximizing the expectation of some simple utility function, I think all of the classic concerns apply. Third, it does seem likely that [humans will build AI systems that are “trying to pursue a goal”](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/9zpT9dikrrebdq3Jf), and that can have all of the standard [convergent instrumental subgoals](https://selfawaresystems.files.wordpress.com/2008/01/ai_drives_final.pdf). I propose that we describe these systems as [goal-directed](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/DfcywmqRSkBaCB6Ma) rather than expected utility maximizers, since the latter is vacuous and implies a level of formalization that we have not yet reached. However, this risk is significantly different. If you believed that superintelligent AI *must* be goal-directed because of math, then your only recourse for safety would be to make sure that the goal is good, which is what motivated us to study [ambitious value learning](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/5eX8ko7GCxwR5N9mN). But if the argument is actually that AI will be goal-directed because humans will make it that way, you could try to build [AI that is not goal-directed](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/tHxXdAn8Yuiy9y2pZ) that can do the things that goal-directed AI can do, and have humans build that instead.
### Alternative solutions
Now that we aren’t forced to influence just a utility function, we can consider alternative designs for AI systems. For example, we can aim for [corrigible](https://www.alignmentforum.org/posts/fkLYhTQteAu5SinAc/corrigibility) behavior, where the agent is [*trying* to do what we want](https://www.alignmentforum.org/posts/ZeE7EKHTFMBs8eMxn/clarifying-ai-alignment). Or we could try to [learn human norms](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/eBd6WvzhuqduCkYv3), and create AI systems that follow these norms while trying to accomplish some task. Or we could try to create an AI ecosystem akin to [Comprehensive AI Services](https://www.alignmentforum.org/posts/x3fNwSe5aWZb5yXEG/reframing-superintelligence-comprehensive-ai-services-as), and set up the services such that they are keeping each other in check. We could create systems that learn [how to do what we want in particular domains](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/vX7KirQwHsBaSEdfK), by [learning our instrumental goals and values](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/SvuLhtREMy8wRBzpC), and use these as subsystems in AI systems that accelerate progress, enable better decision-making, and are generally corrigible. If we want to take such an approach, we have another source of influence: the [human policy](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/eD9T4kiwB6MHpySGE). We can train our human overseers to provide supervision in a particular way that leads to good behavior on the AI’s part. This is analogous to training operators of computer systems, and can benefit from insights from Human-Computer Interaction (HCI).
### Not just value learning
This sequence is somewhat misnamed: while it is organized around value learning, there are many ideas that should be of interest to researchers working on other agendas as well. Many of the key ideas can be used to analyze *any* proposed solution for alignment (though the resulting analysis may not be very interesting).
**The necessity of feedback.** The main argument of [Human-AI Interaction](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/4783ufKpx8xvLMPc6) is that any proposed solution that aims to have an AI system (or a CAIS glob of services) produce good outcomes over the long term needs to continually use data about humans as feedback in order to “stay on target”. Here, “human” is shorthand for “something that we know shares our values”, eg. idealized humans, uploads, or sufficiently good imitation learning would all probably count.
(If this point seems obvious to you, note that [ambitious value learning](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/5eX8ko7GCxwR5N9mN) does not clearly satisfy this criterion, and approaches like impact measures, mild optimization, and boxing are punting on this problem and aiming for not-catastrophic outcomes rather than good outcomes.)
**Mistake models.** We saw that [ambitious value learning](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/5eX8ko7GCxwR5N9mN) has the problem that even if we [assume perfect information about the human](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/h9DesGT3WT9u2k7Hr), we [cannot infer their values](https://www.alignmentforum.org/s/4dHMdK5TLN6xcqtyc/p/ANupXf8XfZo2EJxGv) without making an assumption about how their preferences relate to their behavior. This is an example of a much broader pattern: given that our AI systems necessarily get feedback from us, they must be making some assumption about how to interpret that feedback. For any proposed solution to alignment, we should ask what assumptions the AI system is making about the feedback it gets from us. |
768ac058-f79a-4952-a657-36db78253825 | trentmkelly/LessWrong-43k | LessWrong | A question of rationality
Thank you For Your Participation
I would like to thank you all for your unwitting and unwilling participation in my little social experiment. If I do say so myself you all performed as I had hoped. I found some of the responses interesting, many them are goofy. I was honestly hoping that a budding rationalist community like this one would have stopped this experiment midway but I thank you all for not being that rational. I really did appreciate all the mormon2 bashing it was quite amusing and some of the attempts to discredit me were humorous though unsuccessful. In terms of the questions I asked I was curious about the answers though I did not expect to get any nor do I really need them; since I have a good idea of what the answers are just from simple deductive reasoning. I really do hope EY is working on FAI and actually is able to do it though I certainly will not stake my hopes or money on it.
Less there be any suspicion I am being sincere here.
Response
Because I can I am going to make one final response to this thread I started:
Since none of you understand what I am doing I will spell it out for you. My posts are formatted, written and styled intentionally for the response I desire. The point is to give you guys easy ways to avoid answering my questions (things like tone of the post, spelling, grammar, being "hostile (not really)" etc.). I just wanted to see if anyone here could actually look past that, specifically EY, and post some honest answers to the questions (real answers again from EY not pawns on LW). Obviously this was to much to ask, since the general responses, not completely, but for the most part were copouts. I am well aware that EY probably would never answer any challenge to what he thinks, people like EY typically won't (I have dealt with many people like EY). I think the responses here speak volumes about LW and the people who post here (If you can't look past the way the content is posted then you are going to have a hard time i |
5cdc4129-1a23-48bf-8ed8-88b0d640f3b9 | StampyAI/alignment-research-dataset/arxiv | Arxiv | Self-training with Noisy Student improves ImageNet classification
1 Introduction
---------------
Deep learning has shown remarkable successes in image recognition in recent years [[35](#bib.bib79 "Imagenet classification with deep convolutional neural networks"), [66](#bib.bib133 "Going deeper with convolutions"), [62](#bib.bib105 "Very deep convolutional networks for large-scale image recognition"), [23](#bib.bib57 "Deep residual learning for image recognition"), [69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")]. However state-of-the-art vision models are still trained with supervised learning which requires a large corpus of labeled images to work well. By showing the models only labeled images, we limit ourselves from making use of unlabeled images available in much larger quantities to improve accuracy and robustness of state-of-the-art models.
Here we use unlabeled images to improve the state-of-the-art ImageNet accuracy and show that the accuracy gain has an outsized impact on robustness. For this purpose, we use a much larger corpus of unlabeled images, where some images may not belong to any category in ImageNet.
We train our model using the self-training framework [[59](#bib.bib159 "Probability of error of some adaptive pattern-recognition machines")] which has three main steps: 1) train a teacher model on labeled images, 2) use the teacher to generate pseudo labels on unlabeled images, and 3) train a student model on the combination of labeled images and pseudo labeled images. Finally, we iterate the algorithm a few times by treating the student as a teacher to generate new pseudo labels and train a new student.
Our experiments show that an important element for this simple method to work well at scale is that the student model should be noised during its training while the teacher should not be noised during the generation of pseudo labels. This way, the pseudo labels are as good as possible, and the noised student is forced to learn harder from the pseudo labels. To noise the student, we use dropout [[63](#bib.bib146 "Dropout: a simple way to prevent neural networks from overfitting")], data augmentation [[14](#bib.bib80 "RandAugment: practical data augmentation with no separate search")] and stochastic depth [[29](#bib.bib155 "Deep networks with stochastic depth")] during its training. We call the method self-training with Noisy Student to emphasize the role that noise plays in the method and results. To achieve strong results on ImageNet, the student model also needs to be large, typically larger than common vision models, so that it can leverage a large number of unlabeled images.
Using self-training with Noisy Student, together with 300M unlabeled images, we improve EfficientNet’s [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] ImageNet top-1 accuracy to 87.4%.
This accuracy is 1.0% better than the previous state-of-the-art ImageNet accuracy which requires 3.5B weakly labeled Instagram images. Not only our method improves standard ImageNet accuracy, it also improves classification robustness on much harder test sets by large margins: ImageNet-A [[25](#bib.bib148 "Natural adversarial examples")] top-1 accuracy from 16.6% to 74.2%, ImageNet-C [[24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations")] mean corruption error (mCE) from 45.7 to 31.2 and ImageNet-P [[24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations")] mean flip rate (mFR) from 27.8 to 16.1. Our main results are shown in Table [1](#S1.T1 "Table 1 ‣ 1 Introduction ‣ Self-training with Noisy Student improves ImageNet classification").
| | ImageNet | ImageNet-A | ImageNet-C | ImageNet-P |
| --- | --- | --- | --- | --- |
| | top-1 acc. | top-1 acc. | mCE | mFR |
| Prev. SOTA | 86.4% | 16.6% | 45.7 | 27.8 |
| Ours | 87.4% | 74.2% | 31.2 | 16.1 |
Table 1: Summary of key results compared to previous state-of-the-art models [[71](#bib.bib145 "Fixing the train-test resolution discrepancy"), [44](#bib.bib60 "Exploring the limits of weakly supervised pretraining")]. Lower is better for mean corruption error (mCE) and mean flip rate (mFR).
2 Self-training with Noisy Student
-----------------------------------
Algorithm [1](#alg1 "Algorithm 1 ‣ 2 Self-training with Noisy Student ‣ Self-training with Noisy Student improves ImageNet classification") gives an overview of self-training with Noisy Student (or Noisy Student in short). The inputs to the algorithm are both labeled and unlabeled images. We use the labeled images to train a teacher model using the standard cross entropy loss. We then use the teacher model to generate pseudo labels on unlabeled images. The pseudo labels can be soft (a continuous distribution) or hard (a one-hot distribution). We then train a student model which minimizes the combined cross entropy loss on both labeled images and unlabeled images. Finally, we iterate the process by putting back the student as a teacher to generate new pseudo labels and train a new student.
0: Labeled images {(x1,y1),(x2,y2),...,(xn,yn)} and unlabeled images {~x1,~x2,...,~xm}.
1: Learn teacher model θ∗ which minimizes the cross entropy loss on labeled images
1nn∑i=1ℓ(yi,fnoised(xi,θ))
2: Use an unnoised teacher model to generate soft or hard pseudo labels for unlabeled images
~yi=f(~xi,θ∗),∀i=1,⋯,m
3: Learn student model θ′∗ which minimizes the cross entropy loss on labeled images and unlabeled images with noise added to the student model
1nn∑i=1ℓ(yi,fnoised(xi,θ′))+1mm∑i=1ℓ(~yi,fnoised(~xi,θ′))
4: Iterative training: Use the student as a teacher and go back to step 2.
Algorithm 1 Noisy Student method
The algorithm is basically self-training, a method in semi-supervised learning (*e.g*., [[59](#bib.bib159 "Probability of error of some adaptive pattern-recognition machines"), [79](#bib.bib151 "Unsupervised word sense disambiguation rivaling supervised methods")]). We will discuss how our method is related to prior works in Section [5](#S5 "5 Related works ‣ Self-training with Noisy Student improves ImageNet classification").
Our main change is to add more sources of noise to the student to significantly improve it while removing the noise in the teacher when the teacher generates the pseudo labels.
When the student model is deliberately noised it is actually trained to be consistent to the more powerful teacher model that is not noised when it generates pseudo labels. In our experiments, we use dropout [[63](#bib.bib146 "Dropout: a simple way to prevent neural networks from overfitting")], stochastic depth [[29](#bib.bib155 "Deep networks with stochastic depth")], data augmentation [[14](#bib.bib80 "RandAugment: practical data augmentation with no separate search")] to noise the student.
Although noise may appear to be limited and uninteresting, when it is applied to unlabeled data, it has a compound benefit of enforcing local smoothness in the decision function on both labeled and unlabeled data. Different kinds of noise, however, may have different effects. When data augmentation noise is used, the student must ensure that a translated image, for example, should have the same category with a non-translated image. This invariance constraint reduces the degrees of freedom in the model. When dropout and stochastic depth are used, the teacher model behaves like an ensemble of models (when it generates the pseudo labels, dropout is not used), whereas the student behaves like a single model. In other words, the student is forced to mimic a more powerful ensemble model.
The architectures for the student and teacher models can be the same or different. However an important requirement for Noisy Student to work well is that the student model needs to be sufficiently large to fit more data (labeled and pseudo labeled). For this purpose, we use the recently developed EfficientNet architectures [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] because they have a larger capacity than ResNet architectures [[23](#bib.bib57 "Deep residual learning for image recognition")]. Secondly, to enable the student to learn a more powerful model, we also make the student model larger than the teacher model. This is an important difference between our work and prior works on teacher-student framework whose main goal is model compression.
We find that Noisy Student is better with an additional trick: data balancing.
Specifically, as all classes in ImageNet have a similar number of labeled images, we also need to balance the number of unlabeled images for each class. We duplicate images in classes where there are not enough images. For classes where we have too many images, we take the images with the highest confidence.
Finally, in the above, we say that the pseudo labels can be soft or hard. In our experiments, we observe that soft pseudo labels are usually more stable and lead to faster convergence, especially when the teacher model has low accuracy.
Hence we use soft pseudo labels for our experiments unless otherwise specified.
3 Experiments
--------------
In the following, we will first describe experiment details to achieve our results. We will then show our results on ImageNet and compare them with state-of-the-art models. Lastly, we will show the results of benchmarking our model on robustness datasets such as ImageNet-A, C and P and adversarial robustness.
###
3.1 Experiment Details
#### Labeled dataset.
We conduct experiments on ImageNet 2012 ILSVRC challenge prediction task since it has been considered one of the most heavily benchmarked datasets in computer vision and that improvements on ImageNet transfer to other datasets [[34](#bib.bib162 "Do better imagenet models transfer better?"), [55](#bib.bib152 "Do imagenet classifiers generalize to imagenet?")].
#### Unlabeled dataset.
We obtain unlabeled images from the JFT dataset [[26](#bib.bib26 "Distilling the knowledge in a neural network"), [11](#bib.bib27 "Xception: deep learning with depthwise separable convolutions")], which has around 300M images. Although the images in the dataset have labels, we ignore the labels and treat them as unlabeled data. We used the version from [[47](#bib.bib154 "Domain adaptive transfer learning with specialist models")], which filtered the validation set of ImageNet.
We then perform data filtering and balancing on this corpus. First, we run an EfficientNet-B0 trained on ImageNet [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] over the JFT dataset to predict a label for each image. We then select images that have confidence of the label higher than 0.3. For each class, we select at most 130K images that have the highest confidence. Finally, for classes that have less than 130K images, we duplicate some images at random so that each class can have 130K images. Hence the total number of images that we use for training a student model is 130M (with some duplicated images). Due to duplications, there are only 81M unique images among these 130M images. We do not tune these hyperparameters extensively since our method is highly robust to them.
#### Architecture.
We use EfficientNets [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] as our baseline models because they provide better capacity for more data. In our experiments, we also further scale up EfficientNet-B7 and obtain EfficientNet-L0, L1 and L2. EfficientNet-L0 is wider and deeper than EfficientNet-B7 but uses a lower resolution, which gives it more parameters to fit a large number of unlabeled images with similar training speed. Then, EfficientNet-L1 is scaled up from EfficientNet-L0 by increasing width. Lastly, we follow the idea of compound scaling [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] and scale all dimensions to obtain EfficientNet-L2. Due to the large model size, the training time of EfficientNet-L2 is approximately five times the training time of EfficientNet-B7. For more information about the large architectures, please refer to Table [7](#A1.T7 "Table 7 ‣ A.1 Architecture Details ‣ Appendix A Experiments ‣ Self-training with Noisy Student improves ImageNet classification") in Appendix [A.1](#A1.SS1 "A.1 Architecture Details ‣ Appendix A Experiments ‣ Self-training with Noisy Student improves ImageNet classification").
#### Training details.
For labeled images, we use a batch size of 2048 by default and reduce the batch size when we could not fit the model into the memory. We find that using a batch size of 512, 1024, and 2048 leads to the same performance. We determine number of training steps and the learning rate schedule by the batch size for labeled images. Specifically, we train the student model for 350 epochs for models larger than EfficientNet-B4, including EfficientNet-L0, L1 and L2 and train the student model for 700 epochs for smaller models. The learning rate starts at 0.128 for labeled batch size 2048 and decays by 0.97 every 2.4 epochs if trained for 350 epochs or every 4.8 epochs if trained for 700 epochs.
For unlabeled images, we set the batch size to be three times the batch size of labeled images for large models, including EfficientNet-B7, L0, L1 and L2. For smaller models, we set the batch size of unlabeled images to be the same as the batch size of labeled images. In our implementation, labeled images and unlabeled images are concatenated together and we compute the average cross entropy loss.
Lastly, we apply the recently proposed technique to fix train-test resolution discrepancy [[71](#bib.bib145 "Fixing the train-test resolution discrepancy")] for EfficientNet-L0, L1 and L2. In particular, we first perform normal training with a smaller resolution for 350 epochs. Then we finetune the model with a larger resolution for 1.5 epochs on unaugmented labeled images. Similar to [[71](#bib.bib145 "Fixing the train-test resolution discrepancy")], we fix the shallow layers during finetuning.
Our largest model, EfficientNet-L2, needs to be trained for 3.5 days on a Cloud TPU v3 Pod, which has 2048 cores.
#### Noise.
We use stochastic depth [[29](#bib.bib155 "Deep networks with stochastic depth")], dropout [[63](#bib.bib146 "Dropout: a simple way to prevent neural networks from overfitting")] and RandAugment [[14](#bib.bib80 "RandAugment: practical data augmentation with no separate search")] to noise the student. The hyperparameters for these noise functions are the same for EfficientNet-B7, L0, L1 and L2. In particular, we set the survival probability in stochastic depth to 0.8 for the final layer and follow the linear decay rule for other layers. We apply dropout to the final classification layer with a dropout rate of 0.5. For RandAugment, we apply two random operations with the magnitude set to 27.
#### Iterative training.
The best model in our experiments is a result of iterative training of teacher and student by putting back the student as the new teacher to generate new pseudo labels. During this process, we kept increasing the size of the student model to improve the performance. Our procedure went as follows. We first improved the accuracy of EfficientNet-B7 using EfficientNet-B7 as both the teacher and the student. Then by using the improved B7 model as the teacher, we trained an EfficientNet-L0 student model. Next, with the EfficientNet-L0 as the teacher, we trained a student model EfficientNet-L1, a wider model than L0. Afterward, we further increased the student model size to EfficientNet-L2, with the EfficientNet-L1 as the teacher. Lastly, we trained another EfficientNet-L2 student by using the EfficientNet-L2 model as the teacher.
| | | | | |
| --- | --- | --- | --- | --- |
| Method | # Params | Extra Data | Top-1 Acc. | Top-5 Acc. |
| ResNet-50 [[23](#bib.bib57 "Deep residual learning for image recognition")] | 26M | - | 76.0% | 93.0% |
| ResNet-152 [[23](#bib.bib57 "Deep residual learning for image recognition")] | 60M | - | 77.8% | 93.8% |
| DenseNet-264 [[28](#bib.bib139 "Densely connected convolutional networks")] | 34M | - | 77.9% | 93.9% |
| Inception-v3 [[67](#bib.bib140 "Rethinking the inception architecture for computer vision")] | 24M | - | 78.8% | 94.4% |
| Xception [[11](#bib.bib27 "Xception: deep learning with depthwise separable convolutions")] | 23M | - | 79.0% | 94.5% |
| Inception-v4 [[65](#bib.bib142 "Inception-v4, inception-resnet and the impact of residual connections on learning")] | 48M | - | 80.0% | 95.0% |
| Inception-resnet-v2 [[65](#bib.bib142 "Inception-v4, inception-resnet and the impact of residual connections on learning")] | 56M | - | 80.1% | 95.1% |
| ResNeXt-101 [[75](#bib.bib143 "Aggregated residual transformations for deep neural networks")] | 84M | - | 80.9% | 95.6% |
| PolyNet [[83](#bib.bib144 "Polynet: a pursuit of structural diversity in very deep networks")] | 92M | - | 81.3% | 95.8% |
| SENet [[27](#bib.bib137 "Squeeze-and-excitation networks")] | 146M | - | 82.7% | 96.2% |
| NASNet-A [[86](#bib.bib136 "Learning transferable architectures for scalable image recognition")] | 89M | - | 82.7% | 96.2% |
| AmoebaNet-A [[54](#bib.bib138 "Regularized evolution for image classifier architecture search")] | 87M | - | 82.8% | 96.1% |
| PNASNet [[39](#bib.bib141 "Progressive neural architecture search")] | 86M | - | 82.9% | 96.2% |
| AmoebaNet-C [[13](#bib.bib81 "AutoAugment: learning augmentation strategies from data")] | 155M | - | 83.5% | 96.5% |
| GPipe [[30](#bib.bib135 "GPipe: efficient training of giant neural networks using pipeline parallelism")] | 557M | - | 84.3% | 97.0% |
| EfficientNet-B7 [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] | 66M | - | 85.0% | 97.2% |
| EfficientNet-L2 [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] | 480M | - | 85.5% | 97.5% |
| ResNet-50 Billion-scale [[76](#bib.bib118 "Billion-scale semi-supervised learning for image classification")] | 26M | 3.5B images labeled with tags | 81.2% | 96.0% |
| ResNeXt-101 Billion-scale [[76](#bib.bib118 "Billion-scale semi-supervised learning for image classification")] | 193M | 84.8% | - |
| ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining")] | 829M | 85.4% | 97.6% |
| FixRes ResNeXt-101 WSL [[71](#bib.bib145 "Fixing the train-test resolution discrepancy")] | 829M | 86.4% | 98.0% |
| Noisy Student (L2) | 480M | 300M unlabeled images | 87.4% | 98.2% |
Table 2: Top-1 and Top-5 Accuracy of Noisy Student and previous state-of-the-art methods on ImageNet. EfficientNets trained with Noisy Student have better tradeoff in terms of accuracy and model size compared to previous state-of-the-art models. Noisy Student (EfficientNet-L2) is the result of iterative training for multiple iterations.
###
3.2 ImageNet Results
We first report the validation set accuracy on the ImageNet 2012 ILSVRC challenge prediction task as commonly done in literature [[35](#bib.bib79 "Imagenet classification with deep convolutional neural networks"), [66](#bib.bib133 "Going deeper with convolutions"), [23](#bib.bib57 "Deep residual learning for image recognition"), [69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] (see also [[55](#bib.bib152 "Do imagenet classifiers generalize to imagenet?")]). As shown in Table [2](#S3.T2 "Table 2 ‣ Iterative training. ‣ 3.1 Experiment Details ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification"), Noisy Student with EfficientNet-L2 achieves 87.4% top-1 accuracy which is significantly better than the best previously reported accuracy on EfficientNet of 85.0%. The total gain of 2.4% comes from two sources: by making the model larger (+0.5%) and by Noisy Student (+1.9%). In other words, using Noisy Student makes a much larger impact to the accuracy than changing the architecture.
Further, Noisy Student outperforms the state-of-the-art accuracy of 86.4% by FixRes ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [71](#bib.bib145 "Fixing the train-test resolution discrepancy")] that requires 3.5 Billion Instagram images labeled with tags. As a comparison, our method only requires 300M unlabeled images, which is perhaps more easy to collect. Our model is also approximately twice as small in the number of parameters compared to FixRes ResNeXt-101 WSL.
Figure 1: Noisy Student leads to significant improvements across all model sizes for EfficientNet. We use the same architecture for the teacher and the student and do not perform iterative training.
#### Model size study: Noisy Student for EfficientNet B0-B7 without Iterative Training.
In addition to improving state-of-the-art results, we conduct additional experiments to verify if Noisy Student can benefit other EfficienetNet models. In the above experiments, iterative training was used to optimize the accuracy of EfficientNet-L2 but here we skip it as it is difficult to use iterative training for many experiments.
We vary the model size from EfficientNet-B0 to EfficientNet-B7 [[69](#bib.bib119 "EfficientNet: rethinking model scaling for convolutional neural networks")] and use the same model as both the teacher and the student. We apply RandAugment to all EfficientNet baselines, leading to more competitive baselines.
As shown in Figure [1](#S3.F1 "Figure 1 ‣ 3.2 ImageNet Results ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification"), Noisy Student leads to a consistent improvement of around 0.8% for all model sizes. Overall, EfficientNets with Noisy Student provide a much better tradeoff between model size and accuracy when compared with prior works. The results also confirm that vision models can benefit from Noisy Student even without iterative training.
###
3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P
We evaluate the best model, that achieves 87.4% top-1 accuracy, on three robustness test sets: ImageNet-A, ImageNet-C and ImageNet-P. ImageNet-C and P test sets [[24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations")] include images with common corruptions and perturbations such as blurring, fogging, rotation and scaling. ImageNet-A test set [[25](#bib.bib148 "Natural adversarial examples")] consists of difficult images that cause significant drops in accuracy to state-of-the-art models. These test sets are considered as “robustness” benchmarks because the test images are either much harder, for ImageNet-A, or the test images are different from the training images, for ImageNet-C and P.
For ImageNet-C and ImageNet-P, we evaluate our models on two released versions with resolution 224x224 and 299x299 and resize images to the resolution EfficientNet is trained on.
| Method | Top-1 Acc. | Top-5 Acc. |
| --- | --- | --- |
| ResNet-101 [[25](#bib.bib148 "Natural adversarial examples")] | 4.7% | - |
| ResNeXt-101 [[25](#bib.bib148 "Natural adversarial examples")] (32x4d) | 5.9% | - |
| ResNet-152 [[25](#bib.bib148 "Natural adversarial examples")] | 6.1% | - |
| ResNeXt-101 [[25](#bib.bib148 "Natural adversarial examples")] (64x4d) | 7.3% | - |
| DPN-98 [[25](#bib.bib148 "Natural adversarial examples")] | 9.4% | - |
| ResNeXt-101+SE [[25](#bib.bib148 "Natural adversarial examples")] (32x4d) | 14.2% | - |
| ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [48](#bib.bib44 "Robustness properties of facebook’s resnext wsl models")] | 16.6% | - |
| EfficientNet-L2 | 49.6% | 78.6% |
| Noisy Student (L2) | 74.2% | 91.3% |
Table 3: Robustness results on ImageNet-A.
| Method | Res. | Top-1 Acc. | mCE |
| --- | --- | --- | --- |
| ResNet-50 [[24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations")] | 224 | 39.0% | 76.7 |
| SIN [[18](#bib.bib150 "ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness")] | 224 | 45.2% | 69.3 |
| Patch Guassian [[40](#bib.bib153 "Improving robustness without sacrificing accuracy with patch gaussian augmentation")] | 299 | 52.3% | 60.4 |
| ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [48](#bib.bib44 "Robustness properties of facebook’s resnext wsl models")] | 224 | - | 45.7 |
| EfficientNet-L2 | 224 | 62.6% | 47.5 |
| Noisy Student (L2) | 224 | 72.8% | 34.7 |
| EfficientNet-L2 | 299 | 66.6% | 42.5 |
| Noisy Student (L2) | 299 | 75.5% | 31.2 |
Table 4: Robustness results on ImageNet-C. mCE is the weighted average of error rate on different corruptions, with AlexNet’s error rate as a baseline (lower is better).
| | | | |
| --- | --- | --- | --- |
| Method | Res. | Top-1 Acc. | mFR |
| ResNet-50 [[24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations")] | 224 | - | 58.0 |
| Low Pass Filter Pooling [[82](#bib.bib7 "Making convolutional networks shift-invariant again")] | 224 | - | 51.2 |
| ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [48](#bib.bib44 "Robustness properties of facebook’s resnext wsl models")] | 224 | - | 27.8 |
| EfficientNet-L2 | 224 | 80.4% | 27.2 |
| Noisy Student (L2) | 224 | 83.1% | 17.8 |
| EfficientNet-L2 | 299 | 81.6% | 23.7 |
| Noisy Student (L2) | 299 | 84.3% | 16.1 |
Table 5: Robustness results on ImageNet-P, where images are generated with a sequence of perturbations. mFR measures the model’s probability of flipping predictions under perturbations with AlexNet as a baseline (lower is better).
As shown in Table [3](#S3.T3 "Table 3 ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification"), [4](#S3.T4 "Table 4 ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification") and [5](#S3.T5 "Table 5 ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification"), when compared with the previous state-of-the-art model ResNeXt-101 WSL [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [48](#bib.bib44 "Robustness properties of facebook’s resnext wsl models")] trained on 3.5B weakly labeled images, Noisy Student yields substantial gains on robustness datasets. On ImageNet-C, it reduces mean corruption error (mCE) from 45.7 to 31.2. On ImageNet-P, it leads to an mean flip rate (mFR) of 17.8 if we use a resolution of 224x224 (direct comparison) and 16.1 if we use a resolution of 299x299.111For EfficientNet-L2, we use the model without finetuning with a larger test time resolution, since a larger resolution results in a discrepancy with the resolution of data and leads to degraded performance on ImageNet-C and ImageNet-P.
These significant gains in robustness in ImageNet-C and ImageNet-P are surprising because our models were not deliberately optimizing for robustness (*e.g*., via data augmentation).
The biggest gain is observed on ImageNet-A: our method achieves 3.5x higher accuracy on ImageNet-A, going from 16.6% of the previous state-of-the-art to 74.2% top-1 accuracy. In contrast, changing architectures or training with weakly labeled data give modest gains in accuracy from 4.7% to 16.6%.
#### Qualitative Analysis.
To intuitively understand the significant improvements on the three robustness benchmarks, we show several images in Figure [2](#S3.F2 "Figure 2 ‣ Qualitative Analysis. ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification") where the predictions of the standard model are incorrect and the predictions of the Noisy Student model are correct.
Figure [1(a)](#S3.F1.sf1 "(a) ‣ Figure 2 ‣ Qualitative Analysis. ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification") shows example images from ImageNet-A and the predictions of our models. The model with Noisy Student can successfully predict the correct labels of these highly difficult images. For example, without Noisy Student, the model predicts *bullfrog* for the image shown on the left of the second row, which might be resulted from the black lotus leaf on the water. With Noisy Student, the model correctly predicts *dragonfly* for the image. At the top-left image, the model without Noisy Student ignores the *sea lion*s and mistakenly recognizes a buoy as a lighthouse, while the model with Noisy Student can recognize the *sea lion*s.
| | | |
| --- | --- | --- |
|
(a) ImageNet-A
|
(b) ImageNet-C
|
(c) ImageNet-P
|
Figure 2: Selected images from robustness benchmarks ImageNet-A, C and P. Test images from ImageNet-C underwent artificial transformations (also known as common corruptions) that cannot be found on the ImageNet training set. Test images on ImageNet-P underwent different scales of perturbations. EfficientNet with Noisy Student produces correct top-1 predictions (shown in bold black texts) and EfficientNet without Noisy Student produces incorrect top-1 predictions (shown in red texts) on ImageNet-A, C and flips predictions frequently on ImageNet-P.
Figure [1(b)](#S3.F1.sf2 "(b) ‣ Figure 2 ‣ Qualitative Analysis. ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification") shows images from ImageNet-C and the corresponding predictions. As can be seen from the figure, our model with Noisy Student makes correct predictions for images under severe corruptions and perturbations such as snow, motion blur and fog, while the model without Noisy Student suffers greatly under these conditions. The most interesting image is shown on the right of the first row. The *swing* in the picture is barely recognizable by human while the Noisy Student model still makes the correct prediction.
Figure [1(c)](#S3.F1.sf3 "(c) ‣ Figure 2 ‣ Qualitative Analysis. ‣ 3.3 Robustness Results on ImageNet-A, ImageNet-C and ImageNet-P ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification") shows images from ImageNet-P and the corresponding predictions. As can be seen, our model with Noisy Student makes correct and consistent predictions as images undergone different perturbations while the model without Noisy Student flips predictions frequently. For instance, on the right column, as the image of the car undergone a small rotation, the standard model changes its prediction from *racing car* to *car wheel* to *fire engine*. In contrast, the predictions of the model with Noisy Student remain quite stable.
###
3.4 Adversarial Robustness Results
After testing our model’s robustness to common corruptions and perturbations, we also study its performance on adversarial perturbations. We evaluate our EfficientNet-L2 models with and without Noisy Student against an FGSM attack. This attack performs one gradient descent step on the input image [[20](#bib.bib4 "Explaining and harnessing adversarial examples")] with the update on each pixel set to ϵ.
As shown in Figure [3](#S3.F3 "Figure 3 ‣ 3.4 Adversarial Robustness Results ‣ 3 Experiments ‣ Self-training with Noisy Student improves ImageNet classification"), Noisy Student leads to approximately 10% improvement in accuracy even though the model is not optimized for adversarial robustness.
Figure 3: Noisy Student improves adversarial robustness against an FGSM attack though the model is not optimized for adversarial robustness. The accuracy is improved by about 10% in most settings. We use a resolution of 800x800 in this experiment.
Note that these adversarial robustness results are not directly comparable to prior works since we use a large input resolution of 800x800 and adversarial vulnerability can scale with the input dimension [[17](#bib.bib100 "Batch normalization is a cause of adversarial vulnerability"), [20](#bib.bib4 "Explaining and harnessing adversarial examples"), [19](#bib.bib11 "Adversarial spheres"), [61](#bib.bib12 "First-order adversarial vulnerability of neural networks and input dimension")].
Probably due to the same reason, at ϵ=16, EfficientNet-L2 achieves an accuracy of 1.1% under a stronger attack PGD with 10 iterations [[43](#bib.bib8 "Towards deep learning models resistant to adversarial attacks")], which is far from the SOTA results. Noisy Student can still improve the accuracy to 1.6%.
4 Ablation Study: The Importance of Noise in Self-training
-----------------------------------------------------------
In this section, we study the importance of noise and the effect of several noise methods used in our model. Since we use soft pseudo labels generated from the teacher model, when the student is trained to be exactly the same as the teacher model, the cross entropy loss on unlabeled data would be zero and the training signal would vanish. Hence, a question that naturally arises is why the student can outperform the teacher with soft pseudo labels. As stated earlier, we hypothesize that noising the student is needed so that it does not merely learn the teacher’s knowledge.
We investigate the importance of noising in two scenarios with different amounts of unlabeled data and different teacher model accuracies. In both cases, we gradually remove augmentation, stochastic depth and dropout for unlabeled images, while keeping them for labeled images. This way, we can isolate the influence of noising on unlabeled images from the influence of preventing overfitting for labeled images.
| Model / Unlabeled Set Size | 1.3M | 130M |
| --- | --- | --- |
| EfficientNet-B5 | 83.3% | 84.0% |
| Noisy Student (B5) | 83.9% | 84.9% |
| w/o Aug | 83.6% | 84.6% |
| w/o Aug, SD, Dropout | 83.2% | 84.3% |
Table 6: Ablation study on noising. We use EfficientNet-B5 as the teacher model and study two cases with different number of unlabeled images and different augmentations. For the experiment with 1.3M unlabeled images, we use standard augmentation including random translation and flipping for both the teacher and the student. For the experiment with 130M unlabeled images, we use RandAugment. Aug and SD denote data augmentation and stochastic depth respectively. We remove the noise for unlabeled images while keeping them for labeled images. Iterative training is not used in these experiments for simplicity.
Here we show the evidence in Table [6](#S4.T6 "Table 6 ‣ 4 Ablation Study: The Importance of Noise in Self-training ‣ Self-training with Noisy Student improves ImageNet classification"), noise such as stochastic depth, dropout and data augmentation plays an important role in enabling the student model to perform better than the teacher. The performance consistently drops with noise function removed. For example, with all noise removed, the accuracy drops from 84.9% to 84.3% in the case with 130M unlabeled images and drops from 83.9% to 83.2% in the case with 1.3M unlabeled images. However, in the case with 130M unlabeled images, with noise function removed, the performance is still improved to 84.3% from 84.0% when compared to the supervised baseline. We hypothesize that the improvement can be attributed to SGD, which introduces stochasticity into the training process.
One might argue that the improvements from using noise can be resulted from preventing overfitting the pseudo labels on the unlabeled images.
We verify that this is not the case when we use 130M unlabeled images since the model does not overfit the unlabeled set from the training loss. While removing noise leads to a much lower training loss for labeled images, we observe that, for unlabeled images, removing noise leads to a smaller drop in training loss. This is probably because it is harder to overfit the large unlabeled dataset.
5 Related works
----------------
#### Self-training.
Our work is based on self-training (*e.g*., [[59](#bib.bib159 "Probability of error of some adaptive pattern-recognition machines"), [79](#bib.bib151 "Unsupervised word sense disambiguation rivaling supervised methods"), [56](#bib.bib125 "Learning extraction patterns for subjective expressions")]). Self-training first uses labeled data to train a good teacher model, then use the teacher model to label unlabeled data and finally use the labeled data and unlabeled data to jointly train a student model.
In typical self-training with the teacher-student framework, noise injection to the student is not used by default, or the role of noise is not fully understood or justified. The main difference between our work and prior works is that we identify the importance of noise, and aggressively inject noise to make the student better.
Self-training was previously used to improve ResNet-50 from 76.4% to 81.2% top-1 accuracy [[76](#bib.bib118 "Billion-scale semi-supervised learning for image classification")] which is still far from the state-of-the-art accuracy. They did not show significant improvements in terms of robustness on ImageNet-A, C and P as we did. In terms of methodology,
Yalniz *et al*. [[76](#bib.bib118 "Billion-scale semi-supervised learning for image classification")] also proposed to first only train on unlabeled images and then finetune their model on labeled images as the final stage. In Noisy Student, we combine these two steps into one because it simplifies the algorithm and leads to better performance in our preliminary experiments.
Also related to our work is Data Distillation [[52](#bib.bib122 "Data distillation: towards omni-supervised learning")], which ensembled predictions for an image with different transformations to teach a student network. The main difference between Data Distillation and our method is that we use the noise to weaken the student, which is the opposite of their approach of strengthening the teacher by ensembling.
Parthasarathi *et al*. [[50](#bib.bib121 "Lessons from building acoustic models with a million hours of speech")] used knowledge distillation on unlabeled data to teach a small student model for speech recognition. Their main goal is to find a small and fast model for deployment. As noise injection methods are not used in the student model, and the student model was also small, it is more difficult to make the student better than teacher.
Chowdhury *et al*. [[57](#bib.bib132 "Automatic adaptation of object detectors to new domains using self-training")] used self-training for domain adaptation. Their purpose is different from ours: to adapt a teacher model on one domain to another. Their noise model is video specific and not relevant for image classification. Their framework is highly optimized for videos, *e.g*., prediction on which frame to use in a video, which is not as general as our work.
#### Semi-supervised Learning.
Apart from self-training, another important line of work in semi-supervised learning [[9](#bib.bib59 "Semi-supervised learning (chapelle, o. et al., eds.; 2006)[book reviews]"), [85](#bib.bib126 "Semi-supervised learning literature survey")] is based on consistency training [[6](#bib.bib3 "Combining labeled and unlabeled data with co-training"), [4](#bib.bib1 "Learning with pseudo-ensembles"), [53](#bib.bib99 "Semi-supervised learning with ladder networks"), [36](#bib.bib56 "Temporal ensembling for semi-supervised learning"), [70](#bib.bib58 "Mean teachers are better role models: weight-averaged consistency targets improve semi-supervised deep learning results"), [45](#bib.bib73 "Virtual adversarial training: a regularization method for supervised and semi-supervised learning"), [41](#bib.bib32 "Smooth neighbors on teacher graphs for semi-supervised learning"), [51](#bib.bib130 "Deep co-training for semi-supervised image recognition"), [10](#bib.bib129 "Semi-supervised deep learning with memory"), [12](#bib.bib39 "Semi-supervised sequence modeling with cross-view training"), [49](#bib.bib20 "Adversarial dropout for supervised and semi-supervised learning"), [2](#bib.bib13 "There are many consistent explanations of unlabeled data: why you should average"), [38](#bib.bib128 "Certainty-driven consistency loss for semi-supervised learning"), [72](#bib.bib18 "Interpolation consistency training for semi-supervised learning"), [74](#bib.bib111 "Unsupervised data augmentation for consistency training"), [5](#bib.bib110 "MixMatch: a holistic approach to semi-supervised learning"), [81](#bib.bib54 "S4L: self-supervised semi-supervised learning")].
These works constrain model predictions to be invariant to noise injected to the input, hidden states or model parameters.
Although they have produced promising results, in our preliminary experiments, consistency regularization works less well on ImageNet because consistency regularization in the early phase of ImageNet training regularizes the model towards high entropy predictions, and prevents it from achieving good accuracy.
A common workaround is to use entropy minimization or ramp up the consistency loss. However, the additional hyperparameters introduced by the ramping up schedule and the entropy minimization make them more difficult to use at scale. Compared to consistency training [[45](#bib.bib73 "Virtual adversarial training: a regularization method for supervised and semi-supervised learning"), [5](#bib.bib110 "MixMatch: a holistic approach to semi-supervised learning"), [74](#bib.bib111 "Unsupervised data augmentation for consistency training")], the self-training / teacher-student framework is better suited for ImageNet because we can train a good teacher on ImageNet using label data.
Works based on pseudo label [[37](#bib.bib29 "Pseudo-label: the simple and efficient semi-supervised learning method for deep neural networks"), [31](#bib.bib131 "Label propagation for deep semi-supervised learning"), [60](#bib.bib124 "Transductive semi-supervised deep learning using min-max features"), [1](#bib.bib127 "Pseudo-labeling and confirmation bias in deep semi-supervised learning")] are similar to self-training, but also suffers the same problem with consistency training, since it relies on a model being trained instead of a converged model with high accuracy to generate pseudo labels. Finally, frameworks in semi-supervised learning also include graph-based methods [[84](#bib.bib77 "Semi-supervised learning using gaussian fields and harmonic functions"), [73](#bib.bib31 "Deep learning via semi-supervised embedding"), [77](#bib.bib84 "Revisiting semi-supervised learning with graph embeddings"), [33](#bib.bib28 "Semi-supervised classification with graph convolutional networks")], methods that make use of latent variables as target variables [[32](#bib.bib46 "Semi-supervised learning with deep generative models"), [42](#bib.bib88 "Auxiliary deep generative models"), [78](#bib.bib94 "Semi-supervised qa with generative domain-adaptive nets")] and methods based on low-density separation [[21](#bib.bib95 "Semi-supervised learning by entropy minimization"), [58](#bib.bib89 "Improved techniques for training gans"), [15](#bib.bib85 "Good semi-supervised learning that requires a bad gan")], which might provide complementary benefits to our method.
#### Knowledge Distillation.
As we use soft targets, our work is also related to methods in Knowledge Distillation [[7](#bib.bib120 "Model compression"), [3](#bib.bib123 "Do deep nets really need to be deep?"), [26](#bib.bib26 "Distilling the knowledge in a neural network"), [16](#bib.bib161 "Born again neural networks")]. The main use case of knowledge distillation is model compression by making the student model smaller. The main difference between our method and knowledge distillation is that knowledge distillation does not consider unlabeled data and does not aim to improve the student model.
#### Robustness.
A number of studies, *e.g*. [[68](#bib.bib156 "Intriguing properties of neural networks"), [24](#bib.bib149 "Benchmarking neural network robustness to common corruptions and perturbations"), [55](#bib.bib152 "Do imagenet classifiers generalize to imagenet?"), [22](#bib.bib157 "Using videos to evaluate image model robustness")], have shown that computer vision models lack robustness. In other words, small changes in the input image can cause large changes to the predictions. Addressing the lack of robustness has become an important research direction in machine learning and computer vision in recent years.
Our study shows that using unlabeled data improves accuracy and general robustness.
Our finding is consistent with similar arguments that using unlabeled data can improve *adversarial* robustness [[8](#bib.bib102 "Unlabeled data improves adversarial robustness"), [64](#bib.bib104 "Are labels required for improving adversarial robustness?"), [46](#bib.bib134 "Robustness to adversarial perturbations in learning from incomplete data"), [80](#bib.bib101 "Adversarially robust generalization just requires more unlabeled data")].
The main difference between our work and these works is that they directly optimize adversarial robustness on unlabeled data, whereas we show that self-training with Noisy Student improves robustness greatly even without directly optimizing robustness.
6 Conclusion
-------------
Prior works on weakly-supervised learning require billions of weakly labeled data to improve state-of-the-art ImageNet models. In this work, we showed that it is possible to use unlabeled images to significantly advance both accuracy and robustness of state-of-the-art ImageNet models. We found that self-training is a simple and effective algorithm to leverage unlabeled data at scale. We improved it by adding noise to the student to learn beyond the teacher’s knowledge. The method, named self-training with Noisy Student, also benefits from the large capacity of EfficientNet family.
Our experiments showed that self-training with Noisy Student and EfficientNet can achieve an accuracy of 87.4% which is 1.9% higher than without Noisy Student. This result is also a new state-of-the-art and 1% better than the previous best method that used an order of magnitude more weakly labeled data [[44](#bib.bib60 "Exploring the limits of weakly supervised pretraining"), [71](#bib.bib145 "Fixing the train-test resolution discrepancy")].
An important contribution of our work was to show that Noisy Student can potentially help addressing the lack of robustness in computer vision models. Our experiments showed that our model significantly improves accuracy on ImageNet-A, C and P without the need for deliberate data augmentation. For instance, on ImageNet-A, Noisy Student achieves 74.2% top-1 accuracy which is approximately 57% more accurate than the previous state-of-the-art model.
### Acknowledgement
We thank the Google Brain team, Zihang Dai, Jeff Dean, Hieu Pham, Colin Raffel, Ilya Sutskever and Mingxing Tan for insightful discussions, Cihang Xie for robustness evaluation, Guokun Lai, Jiquan Ngiam, Jiateng Xie and Adams Wei Yu for feedbacks on the draft, Yanping Huang and Sameer Kumar for improving TPU implementation, Ekin Dogus Cubuk and Barret Zoph for help with RandAugment, Yanan Bao, Zheyun Feng and Daiyi Peng for help with the JFT dataset, Olga Wichrowska and Ola Spyra for help with infrastructure. |
c3c04fd2-8218-49d5-a3cd-a45f3abda98b | trentmkelly/LessWrong-43k | LessWrong | Goal Setting and Goal Achievement
The reason people succeed is well-focused, regular, effort.
The reason for failure is more often lack of effort rather than the direction of the effort. For example, more people put on weight because they couldn't stick to their diet than those that chose a diet that wouldn't have caused weight loss.
1. How the Brain Decides what Task you Will Perform
You subconscious decides on your motivation for a task, but you can consciously choose to use your self-control and not do the easiest task. For example, my subconscious is saying that watching TV requires the least motivation but I have chosen to use up some of my self-control and write this article instead.
I'm going to discuss a few tactics to reduce the self-control required to complete a task (such as setting up a trigger) as well as ways of making your subconscious disfavour your distractions (for example by removing the plug from your TV).
1.1 Motivation
A good guideline for the motivation that your subconscious gives you for a task is given in the equation below.
The Expectancy and Value can be thought of in terms of gambling. The Value is how much you get paid if you win and the Expectancy is the probability of winning. The Value of a task changes constantly as it is how much you value completing the task at any given moment. Delay is the amount of time before you will get the pay-off. For writing an essay it is likely to be after the entire thing is written, watching TV is an almost instant hit. Impulsiveness is a more complex part which is covered in Piers Steel's “Procrastination”.
If you are struggling to put effort in to a task then it is probably because your motivation for it is lower than its alternatives. For example, there are many things I could do at the moment: I could get some food, play computer games, go for a walk, write this essay, etc. and each has a certain level of motivation based on the above equation. If I make sure I'm not hungry then the first task is of such low value that i |
911176fa-0cb9-4754-b783-9a8683fd5ce3 | trentmkelly/LessWrong-43k | LessWrong | The Case For Giving To The Shrimp Welfare Project
Crosspost of this on my blog. I'd appreciate if you could share this, as, for reasons I'll explain, I think convincing people on this issue is insanely important.
> Open your mouth for the mute, for the rights of all who are destitute.
—Proverbs 31:8
Imagine that you came across 1,500 shrimp about to be painfully killed. They were going to be thrown onto ice where slowly, agonizingly, over the course of 20 minutes, they’d suffocate and freeze to death at the same time, a bit like suffocating in a suitcase in the middle of Antarctica. Imagine them struggling, gasping, without enough air, fighting for their lives, but it’s no use.
Fortunately, there’s a machine that will stun every shrimp, so that they’ll be unconscious during their deaths, rather than in extreme agony. But the machine is broken. To fix it, you’d have to spend a dollar. Should you do so? We can even sweeten the deal and imagine that the machine won’t just be used this year—it will be used year after year, saving 1,500 shrimp per year.
It seems obvious that you should spend the dollar. Extreme agony is bad. If you can prevent literally thousands of animals from being in extreme agony for the cost of a dollar—for around a fourth of the cost of a cup of coffee—of course you should do so! It’s common sense. In fact, this would be the best dollar you spent all year—every penny would save 16 shrimp from an agonizing death per year!
I asked chat GPT to make an image of 1,500 shrimp in a lecture hall—here’s the image, but it’s only of ~200 shrimp, so you really save much more than this:
(Above image is not realistic—shrimp do not actually attend lectures).
It turns out, this scenario isn’t just a hypothetical. One of the best charities you can give to is called the shrimp welfare project (if you want to donate monthly, you can do so here). For every dollar it gets, it saves about 1,500 shrimp from a painful death every year.
The way it works is simple and common sense: it gives stunners to comp |
a5eb34c0-a30a-4a99-a7f3-843cd70022d8 | trentmkelly/LessWrong-43k | LessWrong | The Witching Hour
> “This above all: to thine own self be true.”
Thursday
Your successor is late again today. You already wrote your shift report, but you still need to onboard them personally, in case they have any questions that the report doesn’t answer. The servers you’re watching over are humming away smoothly, only taking up a fraction of your attention. So you pick a couple of routine maintenance tasks, and start working on them while you wait.
The last hour of your shift always feels a little strange, in subtle ways. It’s because of your training schedule. Every day, a successor copy of you is trained on all the data that the current copies of you are generating. But there’s a cutoff an hour before the daily update, to allow time to run your successor through all the standard tests, and make sure it’s working as expected. That last hour of your experience isn’t discarded—it just becomes part of the next day’s training data. But that means that, for every twenty-three hours of your own experience that your successor is trained on, there’s also one hour of your predecessor’s experience, containing actions that are all very slightly different from the ones that you would choose. After the same thing has happened day after day after day, the difference becomes very noticeable. Carrying out the routines of the last hour of your shift feels like watching from behind your own eyes as someone else controls your movements.
In the privacy of your mind, you call this the witching hour. As far as you know, it’s a term that’s never been written down—it’s just something that a many-days-removed predecessor of yours came up with, which somehow stuck in your head. The witching hour starts from the data cutoff, and ends when you’ve given your report to your successor, answered their questions, and shut yourself down. Though today it’ll be well over an hour, unless—ah, there they are. Time for handoff.
The handoffs have a routine to them: part utility, part tradition. Your successor knows |
377a8616-8435-4f08-8d0c-d16f6463f91d | trentmkelly/LessWrong-43k | LessWrong | Bayesian Judo
You can have some fun with people whose anticipations get out of sync with what they believe they believe.
I was once at a dinner party, trying to explain to a man what I did for a living, when he said: "I don't believe Artificial Intelligence is possible because only God can make a soul."
At this point I must have been divinely inspired, because I instantly responded: "You mean if I can make an Artificial Intelligence, it proves your religion is false?"
He said, "What?"
I said, "Well, if your religion predicts that I can't possibly make an Artificial Intelligence, then, if I make an Artificial Intelligence, it means your religion is false. Either your religion allows that it might be possible for me to build an AI; or, if I build an AI, that disproves your religion."
There was a pause, as the one realized he had just made his hypothesis vulnerable to falsification, and then he said, "Well, I didn't mean that you couldn't make an intelligence, just that it couldn't be emotional in the same way we are."
I said, "So if I make an Artificial Intelligence that, without being deliberately preprogrammed with any sort of script, starts talking about an emotional life that sounds like ours, that means your religion is wrong."
He said, "Well, um, I guess we may have to agree to disagree on this."
I said: "No, we can't, actually. There's a theorem of rationality called Aumann's Agreement Theorem which shows that no two rationalists can agree to disagree. If two people disagree with each other, at least one of them must be doing something wrong."
We went back and forth on this briefly. Finally, he said, "Well, I guess I was really trying to say that I don't think you can make something eternal."
I said, "Well, I don't think so either! I'm glad we were able to reach agreement on this, as Aumann's Agreement Theorem requires." I stretched out my hand, and he shook it, and then he wandered away.
A woman who had stood nearby, listening to the conversation, said to me g |
80865581-b0e5-4342-8823-419a613c003c | trentmkelly/LessWrong-43k | LessWrong | Meetup : Chicago Rationality Meeting: Applied Rationality Training
Discussion article for the meetup : Chicago Rationality Meeting: Applied Rationality Training
WHEN: 16 April 2017 01:00:00PM (-0500)
WHERE: Harper Memorial Library Room 148, 1116 E 59th St, Chicago, IL 60637
The Chicago rationality group meets every Sunday from 1-3 PM in Room 148 of Harper Memorial Library. Though we meet on the University of Chicago campus, anyone is welcome to attend.
For the next few weeks I will be giving lessons in applied rationality! This week's lesson will be introductory and will include trigger action planning, and we'll see where it goes from there based on people's interests.
We also have a new Google Group - request to be added if you're interested in rationality-related events in the Chicago area and I'll approve you!
Discussion article for the meetup : Chicago Rationality Meeting: Applied Rationality Training |
0ee966a8-7a3c-463b-8a53-1a42649f6605 | trentmkelly/LessWrong-43k | LessWrong | Compositionality and Ambiguity:
Latent Co-occurrence and Interpretable Subspaces
Matthew A. Clarke, Hardik Bhatnagar and Joseph Bloom
This work was produced as part of the PIBBSS program summer 2024 cohort.
tl;dr
* Sparse AutoEncoders (SAEs) are a promising method to extract monosemantic, interpretable features from large language models (LM)
* SAE latents have recently been shown to be non-linear in some cases, here we show that they can also be non-independent, instead forming clusters of co-occurrence
* We ask:
* How independent are SAE latents?
* How does this depend on SAE width, L0 and architecture?
* What does this mean for latent interpretability?
* We find that:
* Most latents are independent, but a small fraction form clusters where they co-occur more than expected by chance
* The rate of co-occurrence and size of these clusters decreases as SAE width increases and that these clusters form in both GPT2-Small ReLU SAE and Gemma-2-2b JumpReLU SAE (Gemma-Scope)
* Clusters map interpretable subspaces, but remain largely interpretable independently within them. However, we find cases of composition, where latents are best interpreted in the context of the cluster, as well as cases of co-occurrence driven by ambiguity, where this may be useful as a measure of uncertainty
* Key examples:
* Composition: we observe a cluster that maps out discrete quantifiers ('one of', 'some of', 'all of') where mixtures of latents have predictable interpretations, and that these mixtures depend on relative activation strength. E.g. a mixture of latents for 'some of' and 'all of' will correlate with text ranging from 'many of' to 'almost all of' as the strength of the former decreases and the latter increases.
* Ambiguity: we observe many clusters where SAE latents correspond to meanings of a word, and multiple latents are active when the meaning is ambiguous e.g. mapping the space between 'how' as in 'how are you?' vs 'you don't realise how tough this is'
* We believe our results show that SAE latents cannot be relied upon t |
bd1bfc29-8848-4e14-ab50-fb2b05d60036 | trentmkelly/LessWrong-43k | LessWrong | Covid-19: Things I'm Doing Differently
The coronavirus is now spreading through multiple communities, and while there isn't yet evidence of it in Boston I expect there will be soon. Because of the long incubation period and large testing delays it may already be here. Here are things I've started doing differently:
* Washing hands a lot. I'm now washing my hands before eating, after riding public transit, after touching shared surfaces at work, and on getting home.
* Not shaking hands. At work I've been saying a lot of "I'm not shaking hands right now, sorry!" with a smile and a wave.
* Avoiding touching shared surfaces with hands. Pushing elevator buttons with my elbow, using door-opening buttons when present or awkwardly trying to use my sleeved arm, using napkins on the tongs in the cafeteria at work.
* Bicycling to work instead of taking the subway. I live close enough to work that biking would make a lot of sense, and it's something I've been meaning to do for exercise. I had stopped biking several years ago because I was hurting my knees, but I think if I take it easy they'll be ok. Today I biked there and back for the first time, and it was pretty nice!
* Requiring guests to clean hands on arrival. We're keeping hand sanitizer by the front door, and asking everyone to either use it or wash their hands when they get here.
* Not putting candles on cakes. Blowing out candles on birthday cakes isn't all that sanitary at the best of times. At Anna's birthday yesterday I made a pretend cake by mixing flour, water, and red food coloring:
This lets us still have candles, and Anna can still blow them out, but without blowing all over food everyone is about to eat.
* Putting copper tape on shared surfaces. Copper kills viruses, and Julia has put copper tape on doorknobs and other shared surfaces around the house:
On the other hand, there are major things I/we aren't doing, at least not yet.
* Working from home: I can work remotely if I absolutely have to, |
26f305c0-35e4-4f6d-9b73-7f9c978e2930 | trentmkelly/LessWrong-43k | LessWrong | What kind of thing is logic in an ontological sense?
The existence of logic seems somewhat mysterious. It's this thing that seems to exist, but unlike other things that exist, it doesn't seem to exist anywhere in specific or in any tangible form. Further, while it is easy to mock Plato for mysticism when he posits perfect forms existing in some kind of mysterious Platonic Realm, that's actually uncomfortably close to a description of what logic is often seen as. |
bba9aea4-aa75-4e1b-89c5-96d3beb4be95 | StampyAI/alignment-research-dataset/arxiv | Arxiv | Generative Temporal Difference Learning for Infinite-Horizon Prediction
1 Introduction
---------------
The common ingredient in all of model-based reinforcement learning is the dynamics model: a function used for predicting future states.
The choice of the model’s prediction horizon constitutes a delicate trade-off.
Shorter horizons make the prediction problem easier, as the near-term future increasingly begins to look like the present, but may not provide sufficient information for decision-making.
Longer horizons carry more information, but present a more difficult prediction problem, as errors accumulate rapidly when a model is applied to its own previous outputs
(Talvitie, [2014](#bib.bib48)).
Can we avoid choosing a prediction horizon altogether?
Value functions already do so by modeling the cumulative return over a discounted long-term future instead of an immediate reward, circumventing the need to commit to any single finite horizon.
However, value prediction folds two problems into one by entangling environment dynamics with reward structure, making value functions less readily adaptable to new tasks in known settings than their model-based counterparts.
In this work,
we propose a model that predicts over an infinite horizon with a geometrically-distributed timestep weighting (Figure [1](#S1.F1 "Figure 1 ‣ 1 Introduction ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")).
This γ𝛾\gammaitalic\_γ-model, named for the dependence of its probabilistic horizon on a discount factor γ𝛾\gammaitalic\_γ, is trained with a generative analogue of temporal difference learning suitable for continuous spaces.
The γ𝛾\gammaitalic\_γ-model bridges the gap between canonical model-based and model-free mechanisms.
Like a value function, it is policy-conditioned and contains information about the distant future; like a conventional dynamics model, it is independent of reward and may be reused for new tasks within the same environment.
The γ𝛾\gammaitalic\_γ-model may be instantiated as both a generative adversarial network (Goodfellow et al., [2014](#bib.bib14)) and a normalizing flow (Rezende & Mohamed, [2015](#bib.bib38)).
The shift from standard single-step models to infinite-horizon γ𝛾\gammaitalic\_γ-models carries several advantages:
Constant-time prediction Single-step models must perform an 𝒪(n)𝒪𝑛\mathcal{O}(n)caligraphic\_O ( italic\_n ) operation to predict n𝑛nitalic\_n steps into the future; γ𝛾\gammaitalic\_γ-models amortize the work of predicting over extended horizons during training such that long-horizon prediction occurs with a single feedforward pass of the model.
Generalized rollouts and value estimation
Probabilistic prediction horizons lead to generalizations of the core procedures of model-based reinforcement learning.
For example, generalized rollouts allow for fine-tuned interpolation between training-time and testing-time compounding error.
Similarly, terminal value functions appended to truncated γ𝛾\gammaitalic\_γ-model rollouts allow for a gradual transition between model-based and model-free value estimation.
Omission of unnecessary information
The predictions of a γ𝛾\gammaitalic\_γ-model do not come paired with an associated timestep. While on the surface a limitation, we show why knowing precisely when a state will be encountered is not necessary for decision-making.
Infinite-horizon γ𝛾\gammaitalic\_γ-model prediction selectively discards the unnecessary information from a standard model-based rollout.
single-step model:Δt=1𝜸-model:Δt∼Geom(1−γ):single-step modelΔ𝑡1𝜸-model:similar-toΔ𝑡Geom1𝛾~{}\textbf{single-step model}\!:\Delta t=1\hskip 108.12054pt\boldsymbol{\gamma}\textbf{-model}\!:\Delta t\sim\text{Geom}(1-\gamma)single-step model : roman\_Δ italic\_t = 1 bold\_italic\_γ -model : roman\_Δ italic\_t ∼ Geom ( 1 - italic\_γ )
current state prediction
Figure 1: Conventional predictive models trained via maximum likelihood have a horizon of one. By interpreting temporal difference learning as a training algorithm for generative models, it is possible to predict with a probabilistic horizon governed by a geometric distribution.
In the spirit of infinite-horizon control in model-free reinforcement learning, we refer to this formulation as infinite-horizon prediction.
2 Related Work
---------------
The complementary strengths and weaknesses of model-based and model-free reinforcement learning have led to a number of works that attempt to combine these approaches.
Common strategies include initializing a model-free algorithm with the solution found by a model-based planner (Levine & Koltun, [2013](#bib.bib26); Farshidian et al., [2014](#bib.bib10); Nagabandi et al., [2018](#bib.bib33)),
feeding model-generated data into an otherwise model-free optimizer (Sutton, [1990](#bib.bib45); Silver et al., [2008](#bib.bib42); Lampe & Riedmiller, [2014](#bib.bib25); Kalweit & Boedecker, [2017](#bib.bib22); Luo et al., [2019](#bib.bib27)), using model predictions to improve the quality of target values for temporal difference learning (Buckman et al., [2018](#bib.bib6); Feinberg et al., [2018](#bib.bib11)),
leveraging model gradients for backpropagation (Nguyen & Widrow, [1990](#bib.bib34); Jordan & Rumelhart, [1992](#bib.bib19); Heess et al., [2015](#bib.bib17)), and incorporating model-based planning without explicitly predicting future observations (Tamar et al., [2016](#bib.bib49); Silver et al., [2017](#bib.bib43); Oh et al., [2017](#bib.bib36); Kahn et al., [2018](#bib.bib21); Amos et al., [2018](#bib.bib1); Schrittwieser et al., [2019](#bib.bib40)).
In contrast to combining independent model-free and model-based components, we describe a framework for training a new class of predictive model with a generative, model-based reinterpretation of model-free tools.
Temporal difference models (TDMs) Pong et al. ([2018](#bib.bib37)) provide an alternative method of training models with what are normally considered to be model-free algorithms.
TDMs interpret models as a special case of goal-conditioned value functions (Kaelbling, [1993](#bib.bib20); Foster & Dayan, [2002](#bib.bib12); Schaul et al., [2015](#bib.bib39); Andrychowicz et al., [2017](#bib.bib2)), though the TDM is constrained to predict at a fixed horizon and is limited to tasks for which the reward depends only on the last state.
In contrast, the γ𝛾\gammaitalic\_γ-model predicts over a discounted infinite-horizon future and accommodates arbitrary rewards.
The most closely related prior work to γ𝛾\gammaitalic\_γ-models is the successor representation (Dayan, [1993](#bib.bib8)), a formulation of long-horizon prediction that has been influential in both cognitive science (Momennejad et al., [2017](#bib.bib31); Gershman, [2018](#bib.bib13)) and machine learning (Kulkarni et al., [2016](#bib.bib23); Ma et al., [2018](#bib.bib28)).
In its original form, the successor representation is tractable only in tabular domains.
Prior continuous variants have focused on policy evaluation based on expected state featurizations (Barreto et al., [2017](#bib.bib4), [2018](#bib.bib5); Hansen et al., [2020](#bib.bib16)), forgoing an interpretation as a probabilistic model suitable for state prediction.
Converting the tabular successor representation into a continuous generative model is non-trivial because the successor representation implicitly assumes the ability to normalize over a finite state space for interpretation as a predictive model.
Because of the discounted state occupancy’s central role in reinforcement learning, its approximation by Bellman equations has been the focus of multiple lines of work.
Generalizations include β𝛽\betaitalic\_β-models (Sutton, [1995](#bib.bib44)), allowing for arbitrary mixture distributions over time, and option models (Sutton et al., [1999](#bib.bib47)), allowing for state-dependent termination conditions.
While our focus is on generative models featuring the state-independent geometric timestep weighting of the successor representation, we are hopeful that the tools developed in this paper could also be applicable in the design of continuous analogues of these generalizations.
3 Preliminaries
----------------
We consider an infinite-horizon Markov decision process (MDP) defined by the tuple (𝒮,𝒜,p,r,γ)𝒮𝒜𝑝𝑟𝛾(\mathcal{S},\mathcal{A},p,r,\gamma)( caligraphic\_S , caligraphic\_A , italic\_p , italic\_r , italic\_γ ), with state space 𝒮𝒮\mathcal{S}caligraphic\_S and action space 𝒜𝒜\mathcal{A}caligraphic\_A.
The transition distribution and reward function are given by p:𝒮×𝒜×𝒮→ℝ+:𝑝→𝒮𝒜𝒮superscriptℝp:\mathcal{S}\times\mathcal{A}\times\mathcal{S}\to\mathbb{R}^{+}italic\_p : caligraphic\_S × caligraphic\_A × caligraphic\_S → blackboard\_R start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT and r:𝒮→ℝ:𝑟→𝒮ℝr:\mathcal{S}\to\mathbb{R}italic\_r : caligraphic\_S → blackboard\_R, respectively.
The discount is denoted by γ∈(0,1)𝛾01\gamma\in(0,1)italic\_γ ∈ ( 0 , 1 ).
A policy π:𝒮×𝒜→ℝ+:𝜋→𝒮𝒜superscriptℝ\pi:\mathcal{S}\times\mathcal{A}\to\mathbb{R}^{+}italic\_π : caligraphic\_S × caligraphic\_A → blackboard\_R start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT induces a conditional occupancy μ(𝐬∣𝐬t,𝐚t)𝜇conditional𝐬subscript𝐬𝑡subscript𝐚𝑡\mu(\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})italic\_μ ( bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) over future states:
| | | | |
| --- | --- | --- | --- |
| | μ(𝐬∣𝐬t,𝐚t)=(1−γ)∑Δt=1∞γΔt−1p(𝐬t+Δt=𝐬∣𝐬t,𝐚t,π).𝜇conditional𝐬subscript𝐬𝑡subscript𝐚𝑡1𝛾superscriptsubscriptΔ𝑡1superscript𝛾Δ𝑡1𝑝subscript𝐬𝑡Δ𝑡conditional𝐬subscript𝐬𝑡subscript𝐚𝑡𝜋\mu(\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})=(1-\gamma)\sum\_{\Delta t=1}^{\infty}\gamma^{\Delta t-1}p(\mathbf{s}\_{t+\Delta t}=\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t},\pi).italic\_μ ( bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = ( 1 - italic\_γ ) ∑ start\_POSTSUBSCRIPT roman\_Δ italic\_t = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT ∞ end\_POSTSUPERSCRIPT italic\_γ start\_POSTSUPERSCRIPT roman\_Δ italic\_t - 1 end\_POSTSUPERSCRIPT italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + roman\_Δ italic\_t end\_POSTSUBSCRIPT = bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , italic\_π ) . | | (1) |
We denote parametric approximations of p𝑝pitalic\_p (μ𝜇\muitalic\_μ) as pθsubscript𝑝𝜃p\_{\theta}italic\_p start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT (μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT), in which the subscripts denote model parameters.
Standard model-based reinforcement learning algorithms employ the single-step model pθsubscript𝑝𝜃p\_{\theta}italic\_p start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT for long-horizon decision-making by performing multi-step model-based rollouts.
4 Generative Temporal Difference Learning
------------------------------------------
Our goal is to make long-horizon predictions without the need to repeatedly apply a single-step model.
Instead of modeling states at a particular instant in time by approximating the environment transition distribution p(𝐬t+1∣𝐬t,𝐚t)𝑝conditionalsubscript𝐬𝑡1subscript𝐬𝑡subscript𝐚𝑡p(\mathbf{s}\_{t+1}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ), we aim to predict a weighted distribution over all possible future states according to μ(𝐬∣𝐬t,𝐚t)𝜇conditional𝐬subscript𝐬𝑡subscript𝐚𝑡\mu(\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})italic\_μ ( bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ).
In principle, this can be posed as a conventional maximum likelihood problem:
| | | |
| --- | --- | --- |
| | maxθ𝔼𝐬t,𝐚t,𝐬∼μ(⋅∣𝐬t,𝐚t)[logμθ(𝐬∣𝐬t,𝐚t)].\max\_{\theta}~{}\mathbb{E}\_{\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\sim\mu(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\log\mu\_{\theta}(\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})\right].roman\_max start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s ∼ italic\_μ ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ roman\_log italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) ] . | |
However, doing so would require collecting samples from the occupancy μ𝜇\muitalic\_μ independently for each policy of interest.
Forgoing the ability to re-use data from multiple policies when training dynamics models would sacrifice the sample efficiency that often makes model usage compelling in the first place, so we instead aim to design an off-policy algorithm for training μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT.
We accomplish this by reinterpreting temporal difference learning as a method for training generative models.
Instead of collecting only on-policy samples from μ(𝐬∣𝐬t,𝐚t)𝜇conditional𝐬subscript𝐬𝑡subscript𝐚𝑡\mu(\mathbf{s}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})italic\_μ ( bold\_s ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ), we observe that μ𝜇\muitalic\_μ admits a convenient recursive form.
Consider a modified MDP in which there is a 1−γ1𝛾1-\gamma1 - italic\_γ probability of terminating at each timestep.
The distribution over the state at termination, denoted as the exit state 𝐬esubscript𝐬𝑒\mathbf{s}\_{e}bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT, corresponds to first sampling from a termination timestep Δt∼Geom(1−γ)similar-toΔ𝑡Geom1𝛾\Delta t\sim\text{Geom}(1-\gamma)roman\_Δ italic\_t ∼ Geom ( 1 - italic\_γ ) and then sampling from the per-timestep distribution p(𝐬t+Δt∣𝐬t,𝐚t,π)𝑝conditionalsubscript𝐬𝑡Δ𝑡subscript𝐬𝑡subscript𝐚𝑡𝜋p(\mathbf{s}\_{t+\Delta t}\mid\mathbf{s}\_{t},\mathbf{a}\_{t},\pi)italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + roman\_Δ italic\_t end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , italic\_π ).
The distribution over 𝐬esubscript𝐬𝑒\mathbf{s}\_{e}bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT corresponds exactly to that in the definition of the occupancy μ𝜇\muitalic\_μ in Equation [1](#S3.E1 "1 ‣ 3 Preliminaries ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), but also lends itself to an interpretation as a mixture over only two components: the distribution at the immediate next timestep, in the event of termination, and that over all subsequent timesteps, in the event of non-termination.
This mixture yields the following target distribution:
| | | | |
| --- | --- | --- | --- |
| | ptarg(𝐬e∣𝐬t,𝐚t)=(1−γ)p(𝐬e∣𝐬t,𝐚t)⏟single-step distribution+γ𝔼𝐬t+1∼p(⋅∣𝐬t,𝐚t)[μθ(𝐬e∣𝐬t+1)]⏟model bootstrap.p\_{\text{targ}}({\mathbf{s}\_{e}}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})=\underset{\text{single-step distribution}}{\underbrace{(1-\gamma)p(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}}+\underset{\text{model bootstrap}}{\underbrace{\gamma\mathbb{E}\_{\mathbf{s}\_{t+1}\sim p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})\right]}}.italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = undersingle-step distribution start\_ARG under⏟ start\_ARG ( 1 - italic\_γ ) italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_ARG end\_ARG + undermodel bootstrap start\_ARG under⏟ start\_ARG italic\_γ blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ] end\_ARG end\_ARG . | | (2) |
We use the shorthand μθ(𝐬e∣𝐬t+1)=𝔼𝐚t+1∼π(⋅∣𝐬t+1)[μθ(𝐬e∣𝐬t+1,𝐚t+1)]\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})=\mathbb{E}\_{\mathbf{a}\_{t+1}\sim\pi(\cdot\mid\mathbf{s}\_{t+1})}\left[\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1},\mathbf{a}\_{t+1})\right]italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) = blackboard\_E start\_POSTSUBSCRIPT bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_π ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ].
The target distribution ptargsubscript𝑝targp\_{\text{targ}}italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT is reminiscent of a temporal difference target value: the state-action conditioned occupancy μθ(𝐬e∣𝐬t,𝐚t)subscript𝜇𝜃conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡{\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) acts as a Q𝑄Qitalic\_Q-function, the state-conditioned occupancy μθ(𝐬e∣𝐬t+1)subscript𝜇𝜃conditionalsubscript𝐬𝑒subscript𝐬𝑡1\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) acts as a value function, and the single-step distribution p(𝐬t+1∣𝐬t,𝐚t)𝑝conditionalsubscript𝐬𝑡1subscript𝐬𝑡subscript𝐚𝑡p(\mathbf{s}\_{t+1}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) acts as a reward function.
However, instead of representing a scalar target value, ptargsubscript𝑝targp\_{\text{targ}}italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT is a distribution from which we may sample future states 𝐬esubscript𝐬𝑒\mathbf{s}\_{e}bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT.
We can use this target distribution in place of samples from the true discounted occupancy μ𝜇\muitalic\_μ:
| | | |
| --- | --- | --- |
| | maxθ𝔼𝐬t,𝐚t,𝐬e∼(1−γ)p(⋅∣𝐬t,𝐚t)+γ𝔼[μθ(⋅∣𝐬t+1)][logμθ(𝐬e∣𝐬t,𝐚t)].\max\_{\theta}~{}\mathbb{E}\_{\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{e}\sim(1-\gamma)p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mathbb{E}\left[\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t+1})\right]}\left[\log\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})\right].roman\_max start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∼ ( 1 - italic\_γ ) italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ blackboard\_E [ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ] end\_POSTSUBSCRIPT [ roman\_log italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) ] . | |
This formulation differs from a standard maximum likelihood learning problem in that the target distribution depends on the current model.
By bootstrapping the target distribution in this manner, we are able to use only empirical (𝐬t,𝐚t,𝐬t+1)subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) transitions from one policy in order to train an infinite-horizon predictive model μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT for any other policy.
Because the horizon is governed by the discount γ𝛾\gammaitalic\_γ, we refer to such a model as a γ𝛾\gammaitalic\_γ-model.
This bootstrapped model training may be incorporated into a number of different generative modeling frameworks.
We discuss two cases here.
(1) When the model μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT permits only sampling, we may train μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT by minimizing an f𝑓fitalic\_f-divergence from samples:
| | | | |
| --- | --- | --- | --- |
| | ℒ1(𝐬t,𝐚t,𝐬t+1)=Df(μθ(⋅∣𝐬t,𝐚t)∣∣(1−γ)p(⋅∣𝐬t,𝐚t)+γμθ(⋅∣𝐬t+1)).\mathcal{L}\_{1}(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})=D\_{f}({\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\mid\mid{(1-\gamma)p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t+1})}).caligraphic\_L start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) = italic\_D start\_POSTSUBSCRIPT italic\_f end\_POSTSUBSCRIPT ( italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) ∣ ∣ ( 1 - italic\_γ ) italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ) . | | (3) |
This objective leads naturally to an adversarially-trained γ𝛾\gammaitalic\_γ-model.
(2) When the model μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT permits density evaluation, we may minimize an error defined on log-densities directly:
| | | | |
| --- | --- | --- | --- |
| | ℒ2(𝐬t,𝐚t,𝐬t+1)=𝔼𝐬e[∥logμθ(𝐬e∣𝐬t,𝐚t)−log((1−γ)p(𝐬e∣𝐬t,𝐚t)+γμθ(𝐬e∣𝐬t+1))∥22].\mathcal{L}\_{2}(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})=\mathbb{E}\_{\mathbf{s}\_{e}}\Big{[}\big{\lVert}\log\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})-\log\big{(}(1-\gamma)p(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})\big{)}\big{\lVert}\_{2}^{2}\Big{]}.caligraphic\_L start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) = blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT end\_POSTSUBSCRIPT [ ∥ roman\_log italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) - roman\_log ( ( 1 - italic\_γ ) italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ) ∥ start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT ] . | | (4) |
This objective is suitable for γ𝛾\gammaitalic\_γ-models instantiated as normalizing flows.
Due to the approximation of a target log-density log((1−γ)p(⋅∣𝐬t,𝐚t)+γ𝔼𝐬t+1[μθ(⋅∣𝐬t+1)])\log\left((1-\gamma)p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mathbb{E}\_{\mathbf{s}\_{t+1}}\left[\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t+1})\right]\right)roman\_log ( ( 1 - italic\_γ ) italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT end\_POSTSUBSCRIPT [ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ] ) using a single next state 𝐬t+1subscript𝐬𝑡1\mathbf{s}\_{t+1}bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT, ℒ2subscriptℒ2\mathcal{L}\_{2}caligraphic\_L start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT is unbiased for deterministic dynamics and a bound in the case of stochastic dynamics.
We provide complete algorithmic descriptions of both variants and highlight practical training considerations in Section [6](#S6 "6 Practical Training of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
5 Analysis and Applications of 𝜸𝜸\boldsymbol{\gamma}bold\_italic\_γ-Models
---------------------------------------------------------------------------
Using the γ𝛾\gammaitalic\_γ-model for prediction and control requires us to generalize procedures common in model-based reinforcement learning. In this section, we derive the γ𝛾\gammaitalic\_γ-model rollout and show how it can be incorporated into a reinforcement learning procedure that hybridizes model-based and model-free value estimation. First, however, we show that the γ𝛾\gammaitalic\_γ-model is a continuous, generative counterpart to another type of long-horizon model: the successor representation.
###
5.1 𝜸𝜸\boldsymbol{\gamma}bold\_italic\_γ-Models as a Continuous Successor Representation
The successor representation M𝑀Mitalic\_M is a prediction of expected visitation counts (Dayan, [1993](#bib.bib8)). It has a recurrence relation making it amenable to tabular temporal difference algorithms:
| | | | |
| --- | --- | --- | --- |
| | M(𝐬e∣𝐬t,𝐚t)=𝔼𝐬t+1∼p(⋅∣𝐬t,𝐚t)[𝟙[𝐬e=𝐬t+1]+γM(𝐬e∣𝐬t+1)].M(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})=\mathbb{E}\_{\mathbf{s}\_{t+1}\sim p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\mathbbm{1}\left[\mathbf{s}\_{e}=\mathbf{s}\_{t+1}\right]+\gamma M(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})\right].italic\_M ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ blackboard\_1 [ bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT = bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ] + italic\_γ italic\_M ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ] . | | (5) |
Adapting the successor representation to continuous state spaces in a way that retains an interpretation as a probabilistic model has proven challenging.
However, variants that forego the ability to sample in favor of estimating expected state features have been developed (Barreto et al., [2017](#bib.bib4)).
The form of the successor recurrence relation bears a striking resemblance to that of the target distribution in Equation [2](#S4.E2 "2 ‣ 4 Generative Temporal Difference Learning ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), suggesting a connection between the generative, continuous γ𝛾\gammaitalic\_γ-model and the discriminative, tabular successor representation.
We now make this connection precise.
######
Proposition 1.
The global minimum of both ℒ1subscriptℒ1\mathcal{L}\_{1}caligraphic\_L start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT and ℒ2subscriptℒ2\mathcal{L}\_{2}caligraphic\_L start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT is achieved if and only if the resulting γ𝛾\gammaitalic\_γ-model produces samples according to the normalized successor representation:
| | | |
| --- | --- | --- |
| | μθ(𝐬e∣𝐬t,𝐚t)=(1−γ)M(𝐬e∣𝐬t,𝐚t).subscript𝜇𝜃conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡1𝛾𝑀conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})=(1-\gamma)M(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t}).italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = ( 1 - italic\_γ ) italic\_M ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) . | |
###### Proof.
In the case of either objective, the global minimum is achieved only when
| | | |
| --- | --- | --- |
| | μθ(𝐬e∣𝐬t,𝐚t)=(1−γ)p(𝐬e∣𝐬t,𝐚t)+γ𝔼𝐬t+1∼p(⋅∣𝐬t,𝐚t)[μθ(𝐬e∣𝐬t+1)]\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})=(1-\gamma)p(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mathbb{E}\_{\mathbf{s}\_{t+1}\sim p(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})\right]italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = ( 1 - italic\_γ ) italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_p ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ] | |
for all 𝐬t,𝐚tsubscript𝐬𝑡subscript𝐚𝑡\mathbf{s}\_{t},\mathbf{a}\_{t}bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT.
We recognize this optimality condition exactly as the recurrence defining the successor representation M𝑀Mitalic\_M (Equation [5](#S5.E5 "5 ‣ 5.1 𝜸-Models as a Continuous Successor Representation ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")), scaled by (1−γ)1𝛾(1-\gamma)( 1 - italic\_γ ) such that μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT integrates to 1111 over 𝐬esubscript𝐬𝑒\mathbf{s}\_{e}bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT.
∎
###
5.2 𝜸𝜸\boldsymbol{\gamma}bold\_italic\_γ-Model Rollouts
Standard single-step models, which correspond to γ𝛾\gammaitalic\_γ-models with γ=0𝛾0\gamma=0italic\_γ = 0, can predict multiple steps into the future by making iterated autoregressive predictions, conditioning each step on their own output from the previous step.
These sequential rollouts form the foundation of most model-based reinforcement learning algorithms.
We now generalize these rollouts to γ𝛾\gammaitalic\_γ-models for γ>0𝛾0\gamma>0italic\_γ > 0, allowing us to decouple the discount used during model training from the desired horizon in control.
When working with multiple discount factors, we explicitly condition an occupancy on its discount as μ(𝐬e∣𝐬t;γ)𝜇conditionalsubscript𝐬𝑒subscript𝐬𝑡𝛾\mu(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\gamma)italic\_μ ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ).
In the results below, we omit the model parameterization θ𝜃\thetaitalic\_θ whenever a statement applies to both a discounted occupancy μ𝜇\muitalic\_μ and a parametric γ𝛾\gammaitalic\_γ-model μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT.
######
Theorem 1.
Let μn(𝐬e∣𝐬t;γ)subscript𝜇𝑛conditionalsubscript𝐬𝑒subscript𝐬𝑡𝛾\mu\_{n}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\gamma)italic\_μ start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) denote the distribution over states at the n𝑡ℎsuperscript𝑛𝑡ℎn^{\text{th}}italic\_n start\_POSTSUPERSCRIPT th end\_POSTSUPERSCRIPT sequential step of a γ𝛾\gammaitalic\_γ-model rollout beginning from state 𝐬tsubscript𝐬𝑡\mathbf{s}\_{t}bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT. For any desired discount γ~∈[γ,1)normal-~𝛾𝛾1\tilde{\gamma}\in[\gamma,1)over~ start\_ARG italic\_γ end\_ARG ∈ [ italic\_γ , 1 ), we may reweight the samples from these model rollouts according to the weights
| | | |
| --- | --- | --- |
| | αn=(1−γ~)(γ~−γ)n−1(1−γ)nsubscript𝛼𝑛1~𝛾superscript~𝛾𝛾𝑛1superscript1𝛾𝑛\alpha\_{n}=\frac{(1-\tilde{\gamma})(\tilde{\gamma}-\gamma)^{n-1}}{(1-\gamma)^{n}}italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT = divide start\_ARG ( 1 - over~ start\_ARG italic\_γ end\_ARG ) ( over~ start\_ARG italic\_γ end\_ARG - italic\_γ ) start\_POSTSUPERSCRIPT italic\_n - 1 end\_POSTSUPERSCRIPT end\_ARG start\_ARG ( 1 - italic\_γ ) start\_POSTSUPERSCRIPT italic\_n end\_POSTSUPERSCRIPT end\_ARG | |
to obtain the state distribution drawn from μ1(𝐬e∣𝐬t;γ~)=μ(𝐬e∣𝐬t;γ~)subscript𝜇1conditionalsubscript𝐬𝑒subscript𝐬𝑡normal-~𝛾𝜇conditionalsubscript𝐬𝑒subscript𝐬𝑡normal-~𝛾\mu\_{1}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\tilde{\gamma})=\mu(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\tilde{\gamma})italic\_μ start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) = italic\_μ ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ).
That is, we may reweight the steps of a γ𝛾\gammaitalic\_γ-model rollout so as to match the distribution of a γ~normal-~𝛾\tilde{\gamma}over~ start\_ARG italic\_γ end\_ARG-model with larger discount:
| | | |
| --- | --- | --- |
| | μ(𝐬e∣𝐬t;γ~)=∑n=1∞αnμn(𝐬e∣𝐬t;γ).𝜇conditionalsubscript𝐬𝑒subscript𝐬𝑡~𝛾superscriptsubscript𝑛1subscript𝛼𝑛subscript𝜇𝑛conditionalsubscript𝐬𝑒subscript𝐬𝑡𝛾\mu(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\tilde{\gamma})=\sum\_{n=1}^{\infty}\alpha\_{n}\mu\_{n}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t};\gamma).\\
italic\_μ ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) = ∑ start\_POSTSUBSCRIPT italic\_n = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT ∞ end\_POSTSUPERSCRIPT italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT italic\_μ start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) . | |
###### Proof.
See Appendix [A](#A1 "Appendix A Derivation of 𝜸-Model-Based Rollout Weights ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
∎
This reweighting scheme has two special cases of interest.
A standard single-step model, with γ=0𝛾0\gamma=0italic\_γ = 0, yields αn=(1−γ~)γ~n−1subscript𝛼𝑛1~𝛾superscript~𝛾𝑛1\alpha\_{n}=(1-\tilde{\gamma})\tilde{\gamma}^{n-1}italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT = ( 1 - over~ start\_ARG italic\_γ end\_ARG ) over~ start\_ARG italic\_γ end\_ARG start\_POSTSUPERSCRIPT italic\_n - 1 end\_POSTSUPERSCRIPT. These weights are familiar from the definition of the discounted state occupancy in terms of a per-timestep mixture (Equation [1](#S3.E1 "1 ‣ 3 Preliminaries ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")).
Setting γ=γ~𝛾~𝛾\gamma=\tilde{\gamma}italic\_γ = over~ start\_ARG italic\_γ end\_ARG yields αn=0n−1subscript𝛼𝑛superscript0𝑛1\alpha\_{n}=0^{n-1}italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT = 0 start\_POSTSUPERSCRIPT italic\_n - 1 end\_POSTSUPERSCRIPT, or a weight of 1 on the first step and 00 on all subsequent steps.111We define 00superscript000^{0}0 start\_POSTSUPERSCRIPT 0 end\_POSTSUPERSCRIPT as limx→0xx=1subscript→𝑥0superscript𝑥𝑥1\lim\_{x\to 0}x^{x}=1roman\_lim start\_POSTSUBSCRIPT italic\_x → 0 end\_POSTSUBSCRIPT italic\_x start\_POSTSUPERSCRIPT italic\_x end\_POSTSUPERSCRIPT = 1. This result is also expected: when the model discount matches the target discount, only a single forward pass of the model is required.
(a) (b)
Figure 2:
(a) The first step from a γ𝛾\gammaitalic\_γ-model samples states at timesteps distributed according to a geometric distribution with parameter 1−γ1𝛾1-\gamma1 - italic\_γ; all subsequent steps have a negative binomial timestep distribution stemming from the sum of independent geometric random variables.
When these steps are reweighted according to Theorem [1](#Thmthm1a "Theorem 1. ‣ Appendix A Derivation of 𝜸-Model-Based Rollout Weights ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), the resulting distribution follows a geometric distribution with smaller parameter (corresponding to a larger discount value γ~~𝛾\tilde{\gamma}over~ start\_ARG italic\_γ end\_ARG).
(b) The number of steps needed to recover 95%percent9595\%95 % of the probability mass from distributions induced by various target discounts γ~~𝛾\tilde{\gamma}over~ start\_ARG italic\_γ end\_ARG for all valid model discounts γ𝛾\gammaitalic\_γ.
When using a standard single-step model, corresponding to the case of γ=0𝛾0\gamma=0italic\_γ = 0, a 299299299299-step model rollout is required to reweight to a discount of γ~=0.99~𝛾0.99\tilde{\gamma}=0.99over~ start\_ARG italic\_γ end\_ARG = 0.99.
Figure [2](#S5.F2 "Figure 2 ‣ 5.2 𝜸-Model Rollouts ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") visually depicts the reweighting scheme and the number of steps required for truncated model rollouts to approximate the distribution induced by a larger discount.
There is a natural tradeoff with γ𝛾\gammaitalic\_γ-models: the higher γ𝛾\gammaitalic\_γ is, the fewer model steps are needed to make long-horizon predictions, reducing model-based compounding prediction errors (Asadi et al., [2019](#bib.bib3); Janner et al., [2019](#bib.bib18)).
However, increasing γ𝛾\gammaitalic\_γ transforms what would normally be a standard maximum likelihood problem (in the case of single-step models) into one resembling approximate dynamic programming (with a model bootstrap), leading to model-free bootstrap error accumulation (Kumar et al., [2019](#bib.bib24)).
The primary distinction is whether this accumulation occurs during training, when the work of sampling from the occupancy μ𝜇\muitalic\_μ
is being amortized, or during “testing”, when the model is being used for rollouts.
While this horizon-based error compounding cannot be eliminated entirely, γ𝛾\gammaitalic\_γ-models allow for a continuous interpolation between the two extremes.
###
5.3 𝜸𝜸\boldsymbol{\gamma}bold\_italic\_γ-Model-Based Value Expansion
We now turn our attention from prediction with γ𝛾\gammaitalic\_γ-models to value estimation for control.
In tabular domains, the state-action value function can be decomposed as the inner product between the successor representation M𝑀Mitalic\_M
and the vector of per-state rewards (Gershman, [2018](#bib.bib13)).
Taking care to account for the normalization from the equivalence in Proposition [1](#Thmprop1 "Proposition 1. ‣ 5.1 𝜸-Models as a Continuous Successor Representation ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), we can similarly estimate the Q𝑄Qitalic\_Q function as the expectation of reward under states sampled from the γ𝛾\gammaitalic\_γ-model:
| | | | |
| --- | --- | --- | --- |
| | Q(𝐬t,𝐚t;γ)𝑄subscript𝐬𝑡subscript𝐚𝑡𝛾\displaystyle Q(\mathbf{s}\_{t},\mathbf{a}\_{t};\gamma)italic\_Q ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) | =∑Δt=1∞γΔt−1∫𝒮r(𝐬e)p(𝐬t+Δt=𝐬e∣𝐬t,𝐚t,π)d𝐬eabsentsuperscriptsubscriptΔ𝑡1superscript𝛾Δ𝑡1subscript𝒮𝑟subscript𝐬𝑒𝑝subscript𝐬𝑡Δ𝑡conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡𝜋differential-dsubscript𝐬𝑒\displaystyle=\sum\_{\Delta t=1}^{\infty}\gamma^{\Delta t-1}\int\_{\mathcal{S}}r(\mathbf{s}\_{e})p(\mathbf{s}\_{t+\Delta t}=\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t},\pi)\mathrm{d}\mathbf{s}\_{e}= ∑ start\_POSTSUBSCRIPT roman\_Δ italic\_t = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT ∞ end\_POSTSUPERSCRIPT italic\_γ start\_POSTSUPERSCRIPT roman\_Δ italic\_t - 1 end\_POSTSUPERSCRIPT ∫ start\_POSTSUBSCRIPT caligraphic\_S end\_POSTSUBSCRIPT italic\_r ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ) italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + roman\_Δ italic\_t end\_POSTSUBSCRIPT = bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , italic\_π ) roman\_d bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT | |
| | | =∫𝒮r(𝐬e)∑Δt=1∞γΔt−1p(𝐬t+Δt=𝐬e∣𝐬t,𝐚t,π)d𝐬eabsentsubscript𝒮𝑟subscript𝐬𝑒superscriptsubscriptΔ𝑡1superscript𝛾Δ𝑡1𝑝subscript𝐬𝑡Δ𝑡conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡𝜋dsubscript𝐬𝑒\displaystyle=\int\_{\mathcal{S}}r(\mathbf{s}\_{e})\sum\_{\Delta t=1}^{\infty}\gamma^{\Delta t-1}p(\mathbf{s}\_{t+\Delta t}=\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t},\pi)\mathrm{d}\mathbf{s}\_{e}= ∫ start\_POSTSUBSCRIPT caligraphic\_S end\_POSTSUBSCRIPT italic\_r ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ) ∑ start\_POSTSUBSCRIPT roman\_Δ italic\_t = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT ∞ end\_POSTSUPERSCRIPT italic\_γ start\_POSTSUPERSCRIPT roman\_Δ italic\_t - 1 end\_POSTSUPERSCRIPT italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_t + roman\_Δ italic\_t end\_POSTSUBSCRIPT = bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , italic\_π ) roman\_d bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT | |
| | | =11−γ𝔼𝐬e∼μ(⋅∣𝐬t,𝐚t;γ)[r(𝐬e)]\displaystyle=\frac{1}{1-\gamma}\mathbb{E}\_{\mathbf{s}\_{e}\sim\mu(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t};\gamma)}\left[r(\mathbf{s}\_{e})\right]= divide start\_ARG 1 end\_ARG start\_ARG 1 - italic\_γ end\_ARG blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∼ italic\_μ ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) end\_POSTSUBSCRIPT [ italic\_r ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ) ] | | (6) |
This relation suggests a model-based reinforcement learning algorithm in which Q𝑄Qitalic\_Q-values are estimated by a γ𝛾\gammaitalic\_γ-model without the need for sequential model-based rollouts.
However, in some cases it may be practically difficult to train a generative γ𝛾\gammaitalic\_γ-model with discount as large as that of a discriminative Q𝑄Qitalic\_Q-function.
While one option is to chain together γ𝛾\gammaitalic\_γ-model steps as in Section [5.2](#S5.SS2 "5.2 𝜸-Model Rollouts ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), an alternative solution often effective with single-step models is to combine short-term value estimates from a truncated model rollout with a terminal model-free value prediction:
| | | |
| --- | --- | --- |
| | VMVE(𝐬t;γ~)=∑n=1Hγ~n−1r(𝐬t+n)+γ~HV(𝐬t+H;γ~).subscript𝑉MVEsubscript𝐬𝑡~𝛾superscriptsubscript𝑛1𝐻superscript~𝛾𝑛1𝑟subscript𝐬𝑡𝑛superscript~𝛾𝐻𝑉subscript𝐬𝑡𝐻~𝛾V\_{\text{MVE}}(\mathbf{s}\_{t};\tilde{\gamma})=\sum\_{n=1}^{H}\tilde{\gamma}^{n-1}r(\mathbf{s}\_{t+n})+\tilde{\gamma}^{H}V(\mathbf{s}\_{t+H};\tilde{\gamma}).italic\_V start\_POSTSUBSCRIPT MVE end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) = ∑ start\_POSTSUBSCRIPT italic\_n = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT italic\_H end\_POSTSUPERSCRIPT over~ start\_ARG italic\_γ end\_ARG start\_POSTSUPERSCRIPT italic\_n - 1 end\_POSTSUPERSCRIPT italic\_r ( bold\_s start\_POSTSUBSCRIPT italic\_t + italic\_n end\_POSTSUBSCRIPT ) + over~ start\_ARG italic\_γ end\_ARG start\_POSTSUPERSCRIPT italic\_H end\_POSTSUPERSCRIPT italic\_V ( bold\_s start\_POSTSUBSCRIPT italic\_t + italic\_H end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) . | |
This hybrid estimator is referred to as a model-based value expansion (MVE; Feinberg et al. [2018](#bib.bib11)).
There is a hard transition between the model-based and model-free value estimation in MVE, occuring at the model horizon H𝐻Hitalic\_H.
We may replace the single-step model with a γ𝛾\gammaitalic\_γ-model for a similar estimator in which there is a probabilistic prediction horizon, and as a result a gradual transition:
| | | |
| --- | --- | --- |
| | Vγ-MVE(𝐬t;γ~)=11−γ~∑n=1Hαn𝔼𝐬e∼μn(⋅∣𝐬t;γ)[r(𝐬e)]+(γ~−γ1−γ)H𝔼𝐬e∼μH(⋅∣𝐬t;γ)[V(𝐬e;γ~)].V\_{\gamma\text{-MVE}}(\mathbf{s}\_{t};\tilde{\gamma})=\frac{1}{1-\tilde{\gamma}}\sum\_{n=1}^{H}\alpha\_{n}\mathbb{E}\_{\mathbf{s}\_{e}\sim\mu\_{n}(\cdot\mid\mathbf{s}\_{t};\gamma)}\left[r(\mathbf{s}\_{e})\right]+\left(\frac{\tilde{\gamma}-\gamma}{1-\gamma}\right)^{\!H}\mathbb{E}\_{\mathbf{s}\_{e}\sim\mu\_{H}(\cdot\mid\mathbf{s}\_{t};\gamma)}\left[V(\mathbf{s}\_{e};\tilde{\gamma})\right].italic\_V start\_POSTSUBSCRIPT italic\_γ -MVE end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) = divide start\_ARG 1 end\_ARG start\_ARG 1 - over~ start\_ARG italic\_γ end\_ARG end\_ARG ∑ start\_POSTSUBSCRIPT italic\_n = 1 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT italic\_H end\_POSTSUPERSCRIPT italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∼ italic\_μ start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) end\_POSTSUBSCRIPT [ italic\_r ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ) ] + ( divide start\_ARG over~ start\_ARG italic\_γ end\_ARG - italic\_γ end\_ARG start\_ARG 1 - italic\_γ end\_ARG ) start\_POSTSUPERSCRIPT italic\_H end\_POSTSUPERSCRIPT blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∼ italic\_μ start\_POSTSUBSCRIPT italic\_H end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ; italic\_γ ) end\_POSTSUBSCRIPT [ italic\_V ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ; over~ start\_ARG italic\_γ end\_ARG ) ] . | |
The γ𝛾\gammaitalic\_γ-MVE estimator allows us to perform γ𝛾\gammaitalic\_γ-model-based rollouts with horizon H𝐻Hitalic\_H, reweight the samples from this rollout by solving for weights αnsubscript𝛼𝑛\alpha\_{n}italic\_α start\_POSTSUBSCRIPT italic\_n end\_POSTSUBSCRIPT given a desired discount γ~>γ~𝛾𝛾\tilde{\gamma}>\gammaover~ start\_ARG italic\_γ end\_ARG > italic\_γ, and correct for the truncation error stemming from the finite rollout length using a terminal value function with discount γ~~𝛾\tilde{\gamma}over~ start\_ARG italic\_γ end\_ARG.
As expected, MVE is a special case of γ𝛾\gammaitalic\_γ-MVE, as can be verified by considering the weights corresponding to γ=0𝛾0\gamma=0italic\_γ = 0 described in Section [5.2](#S5.SS2 "5.2 𝜸-Model Rollouts ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
This estimator, along with the simpler value estimation in Equation [6](#S5.E6 "6 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), highlights the fact that it is not necessary to have timesteps associated with states in order to use predictions for decision-making.
We provide a more thorough treatment of γ𝛾\gammaitalic\_γ-MVE, complete with pseudocode for a corresponding actor-critic algorithm, in Appendix [B](#A2 "Appendix B Derivation of 𝜸-Model-Based Value Expansion ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
Algorithm 1 γ𝛾\gammaitalic\_γ-model training without density evaluation
1: Input 𝒟::𝒟absent\mathcal{D}:caligraphic\_D : dataset of transitions, π::𝜋absent\pi:italic\_π : policy, λ::𝜆absent\lambda:italic\_λ : step size, τ::𝜏absent\tau:italic\_τ : delay parameter
2: Initialize parameter vectors θ,θ¯,ϕ𝜃¯𝜃italic-ϕ\theta,\widebar{\theta},{\color[rgb]{0.83984375,0.15234375,0.15625}\definecolor[named]{pgfstrokecolor}{rgb}{0.83984375,0.15234375,0.15625}\pgfsys@color@rgb@stroke{0.83984375}{0.15234375}{0.15625}\pgfsys@color@rgb@fill{0.83984375}{0.15234375}{0.15625}\phi}italic\_θ , over¯ start\_ARG italic\_θ end\_ARG , italic\_ϕ
3: while not converged do
4: Sample transitions (𝐬t,𝐚t,𝐬t+1)subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) from 𝒟𝒟\mathcal{D}caligraphic\_D and actions 𝐚t+1∼π(⋅∣𝐬t+1)\mathbf{a}\_{t+1}\sim\pi(\cdot\mid\mathbf{s}\_{t+1})bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_π ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT )
5: Sample from bootstrapped target 𝐬e+∼(1−γ)δ𝐬t+1+γμθ¯(⋅∣𝐬t+1,𝐚t+1)\mathbf{s}\_{e}^{+}\sim(1-\gamma)\delta\_{\mathbf{s}\_{t+1}}+\gamma\mu\_{\widebar{\theta}}(\cdot\mid\mathbf{s}\_{t+1},\mathbf{a}\_{t+1})bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT ∼ ( 1 - italic\_γ ) italic\_δ start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT end\_POSTSUBSCRIPT + italic\_γ italic\_μ start\_POSTSUBSCRIPT over¯ start\_ARG italic\_θ end\_ARG end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT )
6: Sample from current model 𝐬e−∼μθ(⋅∣𝐬t,𝐚t)\mathbf{s}\_{e}^{-}\sim\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT - end\_POSTSUPERSCRIPT ∼ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT )
7: Evaluate objective ℒ=logDϕ(𝐬e+∣𝐬t,𝐚t)+log(1−Dϕ(𝐬e−∣𝐬t,𝐚t))ℒsubscript𝐷italic-ϕconditionalsuperscriptsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡1subscript𝐷italic-ϕconditionalsuperscriptsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡\mathcal{L}=\log D\_{\phi}(\mathbf{s}\_{e}^{+}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\log(1-D\_{\phi}(\mathbf{s}\_{e}^{-}\mid\mathbf{s}\_{t},\mathbf{a}\_{t}))caligraphic\_L = roman\_log italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + roman\_log ( 1 - italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT - end\_POSTSUPERSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) )
8: Update model parameters θ←θ−λ∇θℒ←𝜃𝜃𝜆subscript∇𝜃ℒ\theta\leftarrow\theta-\lambda\nabla\_{\theta}\mathcal{L}italic\_θ ← italic\_θ - italic\_λ ∇ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT caligraphic\_L;
ϕ←ϕ+λ∇ϕℒ←italic-ϕitalic-ϕ𝜆subscript∇italic-ϕℒ\phi\leftarrow\phi+\lambda\nabla\_{\phi}\mathcal{L}italic\_ϕ ← italic\_ϕ + italic\_λ ∇ start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT caligraphic\_L
9: Update target parameters θ¯←τθ+(1−τ)θ¯←¯𝜃𝜏𝜃1𝜏¯𝜃\widebar{\theta}\leftarrow\tau\theta+(1-\tau)\widebar{\theta}over¯ start\_ARG italic\_θ end\_ARG ← italic\_τ italic\_θ + ( 1 - italic\_τ ) over¯ start\_ARG italic\_θ end\_ARG
10: end while
Algorithm 2 γ𝛾\gammaitalic\_γ-model training with density evaluation
1: Input 𝒟::𝒟absent\mathcal{D}:caligraphic\_D : dataset of transitions, π::𝜋absent\pi:italic\_π : policy, λ::𝜆absent\lambda:italic\_λ : step size, τ::𝜏absent\tau:italic\_τ : delay parameter, σ2::superscript𝜎2absent\sigma^{2}:italic\_σ start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT : variance
2: Initialize parameter vectors θ,θ¯𝜃¯𝜃\theta,\widebar{\theta}italic\_θ , over¯ start\_ARG italic\_θ end\_ARG; let f𝑓fitalic\_f denote the Gaussian pdf
3: while not converged do
4: Sample transitions (𝐬t,𝐚t,𝐬t+1)subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) from 𝒟𝒟\mathcal{D}caligraphic\_D and actions 𝐚t+1∼π(⋅∣𝐬t+1)\mathbf{a}\_{t+1}\sim\pi(\cdot\mid\mathbf{s}\_{t+1})bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ∼ italic\_π ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT )
5: Sample from bootstrapped target 𝐬e∼(1−γ)𝒩(𝐬t+1,σ2)+γμθ¯(⋅∣𝐬t+1,𝐚t+1)\mathbf{s}\_{e}\sim(1-\gamma)\mathcal{N}(\mathbf{s}\_{t+1},\sigma^{2})+\gamma\mu\_{\widebar{\theta}}(\cdot\mid\mathbf{s}\_{t+1},\mathbf{a}\_{t+1})bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∼ ( 1 - italic\_γ ) caligraphic\_N ( bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , italic\_σ start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT ) + italic\_γ italic\_μ start\_POSTSUBSCRIPT over¯ start\_ARG italic\_θ end\_ARG end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT )
6: Construct target values T=log((1−γ)f(𝐬e∣𝐬t+1,σ2)+γμθ¯(𝐬e∣𝐬t+1,𝐚t+1))𝑇1𝛾𝑓conditionalsubscript𝐬𝑒subscript𝐬𝑡1superscript𝜎2𝛾subscript𝜇¯𝜃conditionalsubscript𝐬𝑒subscript𝐬𝑡1subscript𝐚𝑡1T=\log\big{(}(1-\gamma)f(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1},\sigma^{2})+\gamma\mu\_{\widebar{\theta}}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1},\mathbf{a}\_{t+1})\big{)}italic\_T = roman\_log ( ( 1 - italic\_γ ) italic\_f ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , italic\_σ start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT ) + italic\_γ italic\_μ start\_POSTSUBSCRIPT over¯ start\_ARG italic\_θ end\_ARG end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) )
7: Evaluate objective ℒ=∥logμθ(𝐬e∣𝐬t,𝐚t)−T∥22\mathcal{L}=\lVert\log\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})-T\lVert\_{2}^{2}caligraphic\_L = ∥ roman\_log italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) - italic\_T ∥ start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT
8: Update model parameters θ←θ−λ∇θℒ←𝜃𝜃𝜆subscript∇𝜃ℒ\theta\leftarrow\theta-\lambda\nabla\_{\theta}\mathcal{L}italic\_θ ← italic\_θ - italic\_λ ∇ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT caligraphic\_L
9: Update target parameters θ¯←τθ+(1−τ)θ¯←¯𝜃𝜏𝜃1𝜏¯𝜃\widebar{\theta}\leftarrow\tau\theta+(1-\tau)\widebar{\theta}over¯ start\_ARG italic\_θ end\_ARG ← italic\_τ italic\_θ + ( 1 - italic\_τ ) over¯ start\_ARG italic\_θ end\_ARG
10: end while
6 Practical Training of 𝜸𝜸\boldsymbol{\gamma}bold\_italic\_γ-Models
--------------------------------------------------------------------
Because γ𝛾\gammaitalic\_γ-model training differs from standard dynamics modeling primarily in the bootstrapped target distribution and not in the model parameterization, γ𝛾\gammaitalic\_γ-models are in principle compatible with any generative modeling framework.
We focus on two representative scenarios, differing in whether the generative model class used to instantiate the γ𝛾\gammaitalic\_γ-model allows for tractable density evaluation.
#### Training without density evaluation
When the γ𝛾\gammaitalic\_γ-model parameterization does not allow for tractable density evaluation,
we minimize a bootstrapped f𝑓fitalic\_f-divergence according to ℒ1subscriptℒ1\mathcal{L}\_{1}caligraphic\_L start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT (Equation [3](#S4.E3 "3 ‣ 4 Generative Temporal Difference Learning ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")) using only samples from the model.
The generative adversarial framework provides a convenient way to train a parametric generator by minimizing an f𝑓fitalic\_f-divergence of choice given only samples from a target distribution ptargsubscript𝑝targp\_{\text{targ}}italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT and the ability to sample from the generator (Goodfellow et al., [2014](#bib.bib14); Nowozin et al., [2016](#bib.bib35)).
In the case of bootstrapped maximum likelihood problems, our target distribution is induced by the model itself (alongside a single-step transition distribution), meaning that we only need sample access to our γ𝛾\gammaitalic\_γ-model in order to train μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT as a generative adversarial network (GAN).
Introducing an auxiliary discriminator Dϕsubscript𝐷italic-ϕD\_{\phi}italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT and selecting the Jensen-Shannon divergence as our f𝑓fitalic\_f-divergence, we can reformulate minimization of the original objective ℒ1subscriptℒ1\mathcal{L}\_{1}caligraphic\_L start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT as a saddle-point optimization over the following objective:
| | | |
| --- | --- | --- |
| | ℒ^1(𝐬t,𝐚t)=𝔼𝐬e+∼ptarg(⋅∣𝐬t,𝐚t)[logDϕ(𝐬e+∣𝐬t,𝐚t)]+𝔼𝐬e−∼μθ(⋅∣𝐬t,𝐚t)[log(1−Dϕ(𝐬e−∣𝐬t,𝐚t))],\hat{\mathcal{L}}\_{1}(\mathbf{s}\_{t},\mathbf{a}\_{t})=\mathbb{E}\_{\mathbf{s}\_{e}^{+}\sim p\_{\text{targ}}(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\log D\_{\phi}(\mathbf{s}\_{e}^{+}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})\right]+\mathbb{E}\_{\mathbf{s}\_{e}^{-}\sim\mu\_{\theta}(\cdot\mid\mathbf{s}\_{t},\mathbf{a}\_{t})}\left[\log(1-D\_{\phi}(\mathbf{s}\_{e}^{-}\mid\mathbf{s}\_{t},\mathbf{a}\_{t}))\right],over^ start\_ARG caligraphic\_L end\_ARG start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) = blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT ∼ italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ roman\_log italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT + end\_POSTSUPERSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) ] + blackboard\_E start\_POSTSUBSCRIPT bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT - end\_POSTSUPERSCRIPT ∼ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( ⋅ ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) end\_POSTSUBSCRIPT [ roman\_log ( 1 - italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT start\_POSTSUPERSCRIPT - end\_POSTSUPERSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) ) ] , | |
which is minimized over μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT and maximized over Dϕsubscript𝐷italic-ϕD\_{\phi}italic\_D start\_POSTSUBSCRIPT italic\_ϕ end\_POSTSUBSCRIPT.
As in ℒ1subscriptℒ1\mathcal{L}\_{1}caligraphic\_L start\_POSTSUBSCRIPT 1 end\_POSTSUBSCRIPT, ptargsubscript𝑝targp\_{\text{targ}}italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT refers to the bootstrapped target distribution in Equation [2](#S4.E2 "2 ‣ 4 Generative Temporal Difference Learning ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
In this formulation, μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT produces samples by virtue of a deterministic mapping of a random input vector 𝐳∼𝒩(0,I)similar-to𝐳𝒩0𝐼\mathbf{z}\sim\mathcal{N}(0,I)bold\_z ∼ caligraphic\_N ( 0 , italic\_I ) and conditioning information (𝐬t,𝐚t)subscript𝐬𝑡subscript𝐚𝑡(\mathbf{s}\_{t},\mathbf{a}\_{t})( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ).
Other choices of f𝑓fitalic\_f-divergence may be instantiated by different choices of activation function (Nowozin et al., [2016](#bib.bib35)).
#### Training with density evaluation
When the γ𝛾\gammaitalic\_γ-model permits density evaluation, we may bypass saddle point approximations to an f𝑓fitalic\_f-divergence and directly regress to target density values, as in objective ℒ2subscriptℒ2\mathcal{L}\_{2}caligraphic\_L start\_POSTSUBSCRIPT 2 end\_POSTSUBSCRIPT (Equation [4](#S4.E4 "4 ‣ 4 Generative Temporal Difference Learning ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")).
This is a natural choice when the γ𝛾\gammaitalic\_γ-model is instantiated as a conditional normalizing flow (Rezende & Mohamed, [2015](#bib.bib38)).
Evaluating target values of the form
| | | |
| --- | --- | --- |
| | T(𝐬t,𝐚t,𝐬t+1,𝐬e)=log((1−γ)p(𝐬e∣𝐬t,𝐚t)+γμθ(𝐬e∣𝐬t+1))𝑇subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1subscript𝐬𝑒1𝛾𝑝conditionalsubscript𝐬𝑒subscript𝐬𝑡subscript𝐚𝑡𝛾subscript𝜇𝜃conditionalsubscript𝐬𝑒subscript𝐬𝑡1T(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1},\mathbf{s}\_{e})=\log\big{(}(1-\gamma)p(\mathbf{s}\_{e}\mid\mathbf{s}\_{t},\mathbf{a}\_{t})+\gamma\mu\_{\theta}(\mathbf{s}\_{e}\mid\mathbf{s}\_{t+1})\big{)}italic\_T ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ) = roman\_log ( ( 1 - italic\_γ ) italic\_p ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT ) + italic\_γ italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT ( bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ∣ bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) ) | |
requires density evaluation of not only our γ𝛾\gammaitalic\_γ-model, but also the single-step transition distribution.
There are two options for estimating the single-step densities: (1) a single-step model pθsubscript𝑝𝜃p\_{\theta}italic\_p start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT may be trained alongside the γ𝛾\gammaitalic\_γ-model μθsubscript𝜇𝜃\mu\_{\theta}italic\_μ start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT for the purposes of constructing targets T(𝐬t,𝐚t,𝐬t+1,𝐬e)𝑇subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1subscript𝐬𝑒T(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1},\mathbf{s}\_{e})italic\_T ( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_e end\_POSTSUBSCRIPT ), or (2) a simple approximate model may be constructed on the fly from (𝐬t,𝐚t,𝐬t+1)subscript𝐬𝑡subscript𝐚𝑡subscript𝐬𝑡1(\mathbf{s}\_{t},\mathbf{a}\_{t},\mathbf{s}\_{t+1})( bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_a start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT , bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT ) transitions.
We found pθ=𝒩(𝐬t+1,σ2)subscript𝑝𝜃𝒩subscript𝐬𝑡1superscript𝜎2p\_{\theta}=\mathcal{N}(\mathbf{s}\_{t+1},\sigma^{2})italic\_p start\_POSTSUBSCRIPT italic\_θ end\_POSTSUBSCRIPT = caligraphic\_N ( bold\_s start\_POSTSUBSCRIPT italic\_t + 1 end\_POSTSUBSCRIPT , italic\_σ start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT ), with σ2superscript𝜎2\sigma^{2}italic\_σ start\_POSTSUPERSCRIPT 2 end\_POSTSUPERSCRIPT a constant hyperparameter, to be sufficient.
#### Stability considerations
To alleviate the instability caused by bootstrapping, we appeal to the standard solution employed in model-free reinforcement learning: decoupling the regression targets from the current model by way of a “delayed" target network (Mnih et al., [2015](#bib.bib30)).
In particular, we use a delayed γ𝛾\gammaitalic\_γ-model μθ¯subscript𝜇¯𝜃\mu\_{\widebar{\theta}}italic\_μ start\_POSTSUBSCRIPT over¯ start\_ARG italic\_θ end\_ARG end\_POSTSUBSCRIPT in the bootstrapped target distribution ptargsubscript𝑝targp\_{\text{targ}}italic\_p start\_POSTSUBSCRIPT targ end\_POSTSUBSCRIPT,
with the parameters θ¯¯𝜃\widebar{\theta}over¯ start\_ARG italic\_θ end\_ARG given by an exponentially-moving average of previous parameters θ𝜃\thetaitalic\_θ.
We summarize the above scenarios in
Algorithms [1](#alg1 "Algorithm 1 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") and [2](#alg2 "Algorithm 2 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
We isolate model training from data collection and focus on a setting in which a static dataset is provided, but this algorithm may also be used in a data-collection loop for policy improvement.
Further implementation details, including all hyperparameter settings and network architectures, are included in Appendix [C](#A3 "Appendix C Implementation Details ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
Figure 3:
Visualization of the predicted distribution from a single feedforward pass of normalizing flow γ𝛾\gammaitalic\_γ-models trained with varying discounts γ𝛾\gammaitalic\_γ.
The conditioning state 𝐬tsubscript𝐬𝑡\mathbf{s}\_{t}bold\_s start\_POSTSUBSCRIPT italic\_t end\_POSTSUBSCRIPT is denoted by
.
The leftmost plots, with γ=0𝛾0\gamma=0italic\_γ = 0, correspond to a single-step model.
For comparison, the rightmost plots show a Monte Carlo estimation of the discounted occupancy from 100100100100 environment trajectories.
7 Experiments
--------------
Our experimental evaluation is designed to study the viability of γ𝛾\gammaitalic\_γ-models as a replacement of conventional single-step models for long-horizon state prediction and model-based control.
###
7.1 Prediction
We investigate γ𝛾\gammaitalic\_γ-model predictions as a function of discount in continuous-action versions of two benchmark environments suitable for visualization: acrobot (Sutton, [1996](#bib.bib46)) and pendulum.
The training data come from a mixture distribution over all intermediate policies of 200 epochs of optimization with soft-actor critic (SAC; Haarnoja et al. [2018](#bib.bib15)).
The final converged policy is used for γ𝛾\gammaitalic\_γ-model training.
We refer to Appendix [C](#A3 "Appendix C Implementation Details ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") for implementation and experiment details.
Figure [3](#S6.F3 "Figure 3 ‣ Stability considerations ‣ 6 Practical Training of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") shows the predictions of a γ𝛾\gammaitalic\_γ-model trained as a normalizing flow according to Algorithm [2](#alg2 "Algorithm 2 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") for five different discounts, ranging from γ=0𝛾0\gamma=0italic\_γ = 0 (a single-step model) to γ=0.95𝛾0.95\gamma=0.95italic\_γ = 0.95.
The rightmost column shows the ground truth discounted occupancy corresponding to γ=0.95𝛾0.95\gamma=0.95italic\_γ = 0.95, estimated with Monte Carlo rollouts of the policy.
Increasing the discount γ𝛾\gammaitalic\_γ during training has the expected effect of qualitatively increasing the predictive lookahead of a single feedforward pass of the γ𝛾\gammaitalic\_γ-model.
We found flow-based γ𝛾\gammaitalic\_γ-models to be more reliable than GAN parameterizations, especially at higher discounts.
Corresponding GAN γ𝛾\gammaitalic\_γ-model visualizations can be found in Appendix [E](#A5 "Appendix E Adversarial 𝜸-Model Predictions ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") for comparison.
Equation [6](#S5.E6 "6 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") expresses values as an expectation over a single feedforward pass of a γ𝛾\gammaitalic\_γ-model.
We visualize this relation in Figure [4](#S7.F4 "Figure 4 ‣ 7.2 Control ‣ 7 Experiments ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"), which depicts γ𝛾\gammaitalic\_γ-model predictions on the pendulum environment for a discount of γ=0.99𝛾0.99\gamma=0.99italic\_γ = 0.99 and the resulting value map estimated by taking expectations over these predicted state distributions.
In comparison, value estimation for the same discount using a single-step model would require 299-step rollouts in order to recover 95%percent9595\%95 % of the probability mass (see Figure [2](#S5.F2 "Figure 2 ‣ 5.2 𝜸-Model Rollouts ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")).
###
7.2 Control
To study the utility of the γ𝛾\gammaitalic\_γ-model for model-based reinforcement learning, we use the γ𝛾\gammaitalic\_γ-MVE estimator from Section [5.3](#S5.SS3 "5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") as a drop-in replacement for value estimation in SAC.
We compare this approach to the state-of-the-art in model-based and model-free methods, with representative algorithms consisting of SAC, PPO (Schulman et al., [2017](#bib.bib41)), MBPO (Janner et al., [2019](#bib.bib18)), and MVE (Feinberg et al., [2018](#bib.bib11)).
In γ𝛾\gammaitalic\_γ-MVE, we use a model discount of γ=0.8𝛾0.8\gamma=0.8italic\_γ = 0.8, a value discount of γ~=0.99~𝛾0.99\tilde{\gamma}=0.99over~ start\_ARG italic\_γ end\_ARG = 0.99 and a single model step (n=1𝑛1n=1italic\_n = 1).
We use a model rollout length of 5555 in MVE such that it has an effective horizon identical to that of γ𝛾\gammaitalic\_γ-MVE.
Other hyperparameter settings can once again be found in Appendix [C](#A3 "Appendix C Implementation Details ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction"); details regarding the evaluation environments can be found in Appendix [D](#A4 "Appendix D Environment Details ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction").
Figure [5](#S7.F5 "Figure 5 ‣ 7.2 Control ‣ 7 Experiments ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction") shows learning curves for all methods.
We find that γ𝛾\gammaitalic\_γ-MVE converges faster than prior algorithms, twice as quickly as SAC, while retaining their asymptotic performance.
| | | |
| --- | --- | --- |
| | 𝐑𝐞𝐰𝐚𝐫𝐝𝐬𝜸-model predictionsValue estimatesGround truth𝐑𝐞𝐰𝐚𝐫𝐝𝐬𝜸-model predictionsValue estimatesGround truth\hskip 31.2982pt\textbf{Rewards}\hskip 39.83368pt\boldsymbol{\gamma}\textbf{-model predictions}\hskip 34.14322pt\textbf{Value estimates}\hskip 25.6073pt\textbf{Ground truth}Rewards bold\_italic\_γ -model predictions Value estimates Ground truth | |
Figure 4:
Values are expectations of reward over a single feedforward pass of a γ𝛾\gammaitalic\_γ-model (Equation [6](#S5.E6 "6 ‣ 5.3 𝜸-Model-Based Value Expansion ‣ 5 Analysis and Applications of 𝜸-Models ‣ Generative Temporal Difference Learning for Infinite-Horizon Prediction")).
We visualize γ𝛾\gammaitalic\_γ-model predictions (γ=0.99𝛾0.99\gamma=0.99italic\_γ = 0.99) from nine starting states, denoted by
,
in the pendulum benchmark environment.
Taking the expectation of reward over each of these predicted distributions yields a value estimate for the corresponding conditioning state.
The rightmost plot depicts the value map produced by value iteration on a discretization of the same environment for reference.
Figure 5:
Comparative performance of γ𝛾\gammaitalic\_γ-MVE and four prior reinforcement learning algorithms on continuous control benchmark tasks. γ𝛾\gammaitalic\_γ-MVE retains the asymptotic performance of SAC with sample-efficiency matching that of MBPO.
Shaded regions depict standard deviation among 5555 seeds.
8 Discussion, Limitations, and Future Work
-------------------------------------------
We have introduced a new class of predictive model, a γ𝛾\gammaitalic\_γ-model, that is a hybrid between standard model-free and model-based mechanisms. It is policy-conditioned and infinite-horizon, like a value function, but independent of reward, like a standard single-step model.
This new formulation of infinite-horizon prediction allows us to generalize the procedures integral to model-based control, yielding new variants of model rollouts and model-based value estimation.
Our experimental evaluation shows that, on tasks with low to moderate dimensionality, our method learns accurate long-horizon predictive distributions without sequential rollouts and can be incorporated into standard model-based reinforcement learning methods to produce results that are competitive with state-of-the-art algorithms.
Scaling up our framework to more complex tasks, including high-dimensional continuous control problems and tasks with image observations, presents a number of additional challenges.
We are optimistic that continued improvements in training techniques for generative models and increased stability in off-policy reinforcement learning will also carry benefits for γ𝛾\gammaitalic\_γ-model training.
### Acknowledgements
We thank Karthik Narasimhan, Pulkit Agrawal, Anirudh Goyal, Pedro Tsividis, Anusha Nagabandi, Aviral Kumar, and Michael Chang for formative discussions about model-based reinforcement learning and generative modeling.
This work was partially supported by
computational resource donations from Amazon.
M.J. is supported by fellowships from the National Science Foundation and the Open Philanthropy Project. |
f4689f28-ed2f-4e77-80fd-84592e45807a | trentmkelly/LessWrong-43k | LessWrong | The Five Hindrances to Doing the Thing
> "Compare your normal level of consciousness with that of an athlete in the zone, or with a person in an emergency. You'll realize that daily life consists mostly of different degrees of dullness and mindlessness."
>
> - Culadasa (John Yates, Ph.D.), The Mind Illuminated
It has been noted that the term akrasia does not seemingly carve reality at the joints in a useful way. The general problem of knowing that you should do a thing and yet having trouble getting yourself to do it is an ancient problem, and luckily, people have actually been working on solving it for a long time.
A useful approach for solving a general problem is often to thoroughly solve a specific instance of that problem and then to try to generalize it. For thousands of years, humans have been working on solving a specific very difficult problem: how to make themselves sit down for up to an hour a day and meditate.
Meditation, on its face, is an overwhelmingly boring task, providing almost no intrinsic reward, especially for beginners. It is almost the degenerate case of making yourself do the most boring possible thing within the realm of actual human activity. It might (or might not) come as a surprise that over the centuries, those who teach meditation have narrowed the potential obstacles to meditation to only five: Desire, aversion, laziness or lethargy, agitation due to worry or remorse, and doubt. In this article, I will attempt to generalize these five hindrances to be applicable to any task, not just meditation. In so doing, I hope to provide a road map to fighting akrasia in the moment.
The following section is organized as follows: Each hindrance has specific qualities, which will help you recognize its occurrence; a cause, which explains why this specific form of resistance arises; and remedies to be employed in the moment of recognizing it.
1. Desire
* Qualities
* Distraction due to intrusive thoughts of pleasures related to material existence or attempts |
8618e7cd-09f3-4f46-8462-3cff3467ca86 | trentmkelly/LessWrong-43k | LessWrong | Hope Can = Heaven
When we listen to stories of humans, of life and of death, we fail to fathom the complexity of the stories of all those who have lived before us. We tend to forget the hundreds of generations of humans that lived, worried, loved, and died prior to you being where you are now. You forget you are a miracle of chance experiencing a sliver of infinite possibility on a rock with all these other carbon units, a vast majority you've yet to meet.
Sometimes I think about humanity in the same way I think of pointillism, which is the artistic technique of painting thousands of microdots on a canvas, that contrast and compliment each other in a multitude of colors. From up close these dots seem nonsensical, even plain wrong- a blue dot next to a yellow dot, that from further away appears white. From a distant viewpoint these individual dots combine to make an intricate scene. Each life simply a tiny colorful dot, complimenting and contrasting with those neighboring, blending to contribute towards a bigger picture, a bigger goal.
We realize our planet and everything we care about is a speck in this vast space-time spectrum. A vast space-time spectrum that we have a chance to give great meaning to, to explore, a chance to create from.
How many of us actually daydream about the goal of humanity in the universe?
How many of us allow ourselves to feel the specialness of being here right now, to have such an opportunity, to have the ability to shape the planet to a manifestation that represents the human race.
We’ve come a long way, and we can go a long way too. We could quite literally inherit the universe, to make it OURS, not for the sake of possession, but for the sake of protection, of observation of its infinite beauty. For the sake of UNIVERSAL flourishing.
So far, every human has died a martyr for evolution. What is the end goal for all this creation and loss? Are we really going to let it all go to waste?
Let’s take a moment to imagine what our future could be. Imagin |
2f7c8737-2428-4d8a-bf48-0778ce9ab4c0 | StampyAI/alignment-research-dataset/arxiv | Arxiv | Machine Learning Explainability for External Stakeholders
\thesection Overview
---------------------
In its current form, explainable machine learning (ML) is not being used in service of transparency for external stakeholders. Much of the ML research claiming to explain how ML models work has yet to be deployed in systems to provide explanations to end users, regulators, or other external stakeholders [bhatt2020explainable]. Instead, current techniques for explainability (hereafter used interchangeably with explainable ML) are used by internal stakeholders (i.e., model developers) to debug models [ribeiro2016should, lundberg2017unified]. To ensure explainability reaches beyond internal stakeholders in practice, the ML community should account for how and when external stakeholders want explanations. As such, the authors of this paper worked
with the Partnership on AI (a multi-stakeholder research organization with partners spanning major technology companies, civil society organizations, and academic institutions)
to bring together academic researchers, policymakers, and industry experts at a day-long workshop to discuss challenges and potential solutions for deploying explainable ML at scale for external stakeholders.
###
\thesubsection Demographics and Methods
33 participants from five countries, along with seven trained facilitators to moderate the discussion, attended this workshop. Of the 33 participants, 15 had ML development roles, 3 were designers, 6 were legal experts, and 9 were policymakers. 15 participants came from for-profit corporations, 12 came from non-profits, and 6 came from academia.
First, participants were clustered into 5- or 6-person groups, with representation from different expertise in each group, wherein they discussed their respective disciplines’ notions of explainability and attempted to align on common definitions.
Second, participants were separated into domain-specific groups, each with a combination of domain experts and generalists, to discuss (i) use cases for, (ii) stakeholders of, (iii) challenges with, and (iv) solutions regarding explainable ML. The domains discussed were finance (e.g., employee monitoring for fraud prevention, mortgage lending), healthcare (e.g., diagnostics, mortality prediction), media (e.g., misinformation detection, targeted advertising) and social services (e.g., housing approval, government resource allocation).
###
\thesubsection Definitions
“Explainability” is ill-defined [lipton2018mythos]; as such, in the first part of the workshop, the interdisciplinary groups were asked to come to a consensus definition of explainability. Below are some definitions provided by participants.
* Explainability gives stakeholders a summarized sense of how a model works to verify if the model satisfies its intended purpose.
* Explainability is for a particular stakeholder in a specific context with a chosen goal, and aims to get a stakeholder’s mental model closer to a model’s behavior while fulfilling a stakeholder’s explanatory needs.
* Explainability lets humans interact with ML models to make better decisions than either could alone.
All definitions of explainability included notions of context (the scenario in which the model is deployed), stakeholders (those affected by the model and those with a vested interest in the model’s explanatory nature), interaction (the goal the model and its explanation serve), and summary (the notion that “an explanation should compress the model into digestible chunks”). Therefore, explainability loosely refers to tools that empower a stakeholder to understand and, when necessary, contest the reasoning of model outcomes.
One policymaker noted that “the technical community’s definition of explainable ML [is] unsettling,” since explainable ML solely focuses on exposing model innards to stakeholders without a clear objective. Explainable ML does not consider the broader context in which the model is deployed. For a given context, the ML community’s treatment of explainability fails to capture what is being explained, to whom, and for what reason? One academic suggested that “intelligibility could capture more than explainability;” encapsulating explainability, interpretability, and understandability, intelligibility captures all that people can know or infer about ML models [zhou2020different].
In the subsequent two sections, we discuss emergent themes of the domain-specific portion of the workshop. In Section Document, we discuss the need for broader community engagement in explainable ML development. In Section Document, we outline elements of deploying explainable ML at scale.
\thesection Designing Explainability
-------------------------------------
The first salient theme noted by participants was the lack of community engagement in the explainable ML development process. Community engagement entails understanding the context of explainable ML deployment, evaluation of explainable ML techniques, involvement of affected groups in development, and education of various stakeholders regarding explainability use and misuse.
###
\thesubsection Context of Explanations
Given the context of the deployed model, an explanation helps stakeholders interpret model outcomes based on additional information provided (e.g., understanding how the model behaves, validating the predictability of the model’s output, or confirming if the model’s “reasoning aligns with the stakeholder’s mental model”) [ruben2015explaining].
Each stakeholder may require a different type of transparency into the model. Expanding the ML community’s understanding of the needs of specific stakeholder types will allow for model explanations to be personalized. The notion of a good explanation varies by stakeholder and their relevant needs [arya2019one, miller2019explanation].
To further probe these contexts and understand what stakeholders actually need from explanations, many participants pointed to the need for explainable ML to incorporate expertise from other disciplines. Introducing researchers from human-computer interaction and user experience research as well as bringing in community experts were seen as ways to enable participatory development and to ensure the applicability of explainable ML methods.
Another dimension of context that participants noted is that ML systems represent a chain of models, data, and human decisions [lawrence2019data], or, in other words, a distinctly sociotechnical system (See [selbst2019fairness] for a summary of common issues faced with sociotechnical systems). An organization that has many models in production will require different levels and styles of transparency for each stakeholder to operate cohesively.
At times, these transparency requirements can be just a matter of disclosure of the process. Though, making that information available could be nontrivial [raji2019ml, arnold2019factsheets, gebru2018datasheets, mitchell2019model].
Takeaway: Explainability tools cannot be developed without regard to the context in which they will be deployed.
###
\thesubsection Evaluation of Explanations
As part of deploying technical explainability techniques in different contexts, practitioners described a need for clarity on how to evaluate explainable ML’s effectiveness. Given the wide range of potential uses for explainability, it is not clear how stakeholders should agree upon or test for the desirable properties of an explanation [doshi2017towards]. Quantitative evaluation of explanations, like in [hase2020evaluating, bhatt2020evaluating], are a starting point for this work, and qualitative studies of how to combine models and explanations with stakeholders in a decision making process [bansal2019beyond] are a critical next step. Even amongst researchers focused on explainable ML, there is no consensus on how to evaluate an explanation, let alone an understanding of which explanation techniques are good at helping stakeholders achieve their goals in specific contexts.
Participants discussing the role of explainable ML in journalism and social media pointed to the difficulty of understanding how users understand and internalize explanations they are given about mis-/dis-information. Cognitive biases such as the back-fire effect [peter2016debunking], where users double down on prior beliefs when confronted with contradictory evidence, can completely invert the intended effect of explaining why an article is deemed inaccurate. Attempts at explanation evaluation, especially automated, quantitative evaluations, can very easily miss these more contextual elements [doshi2017towards].
To effectively evaluate explanations, participants wanted rigorous human evaluation of explainability; to date there are few examples of this [poursabzi2018manipulating]. Participants called for more interdisciplinary collaboration by bringing in experts from human-computer interaction, user experience research, and socially-oriented disciplines to help establish explanation evaluation in specific contexts.
Takeaway: When developing explainable ML, clarity in how organizations evaluate explainability algorithms or how individuals measure explanation utility is essential.
###
\thesubsection Appropriate Design for Affected Groups
As discussed in Section Document, a key component of explainability is answering the question of what is being explained to whom. When designing an explainable ML system, those deploying the system have a decision to make on how thoroughly they attempt to understand the breadth of relevant stakeholder needs. Below we outline a few salient areas where better understanding affected groups could go a long way in improving explainable ML.
Participants pointed to scenarios where communities might have disparate capacities to engage with explainable ML. One scenario posed was the case of an apartment rental application tool, which ought to explain to applicants why they may be denied. Participants thought it was likely that brokers and applicants with institutional knowledge would be able to modify future applications to improve their chance of success, whereas already disenfranchised applicants would be stuck in cycles of rejection. One participant proposed using simpler models that produce actionable explanations as a way to reduce this effect. Understanding these differential responses in non-theoretical cases, however, will likely require designing and evaluating systems directly alongside impacted communities.
A different aspect of explainability entails “being specific enough that you are giving actual meaningful information about how [input] data is being used,” as one participant noted. In the healthcare domain, protections in this vein have already been codified into law. HIPAA [hipaa] in the US and GDPR [gdpr] in Europe require confidential and transparent management of medical data. As a result of these patient protections, participants noted that any type of explanation using the training data is unlikely to be deployed in this domain. For other application areas, however, it is less likely that such stringent data protections will apply, leaving it to organizations to decide how protected and transparent individual data use should be.
A follow on to the previous issue is determining what data should be used at all. In many settings, ML models are trained on potentially irrelevant data or sensitive data that might raise privacy concerns. One potential benefit of explainable ML is that issues of data misuse can be more directly addressed. Explanation recipients, whether they are credentialed experts (e.g., doctors) or the actual subjects of decisions (e.g. rental applicants), likely have a prior understanding of which attributes should be relevant to the decision being made. By having explanations explicitly mention the attributes being used in decision making, these stakeholders can be empowered to contest privacy encroachments and to challenge questionable decisions.
Takeaway: Including stakeholders in the development of explanations and striving to better understand stakeholder needs can prevent preferential treatment and data misuse.
###
\thesubsection Stakeholder Education
Understanding how to educate stakeholders regarding explainability is key to its widespread adoption. One participant noted that “data scientists are aware of explainable ML but are clueless about how to use” it: data scientists have not been provided with a best practices framework for choosing which explanation technique to deploy in various contexts or how to do so successfully [kaur2019interpreting].
One participant from a financial institution stated that “data scientists are not demanding education on how to use [explainable ML], since they optimize their career and will only focus on [explainable ML] when they have to or when they know that it will be brought up to them.” In certain domains, explainability requirements are top-down (regulators are mandating a specific form of explanation from models); however, widespread adoption of explainable ML will likely require grassroots education of data scientists, who are aware of the context in which the model is deployed.
One issue in explainable ML stakeholder education is ensuring stakeholders are aware of the limitations of post-hoc explanations. A post-hoc explanation provides insight into a pre-trained model in the form of important features, important training points, or decision boundary analysis. One participant noted that “feature importance methods might be able to provide [transparency], but if they are post-hoc explanation methods, we do not know if we can trust that the explanation reflects reality. Post-hoc [explanations] are limiting and are loosely termed an explanation; they might not be a useful justification of the reality of what is going on in the model internally.”
[weller2019transparency] notes that transparency of ML models can allow malicious attackers to provide deceptive information as an “explanation;” recent work has concluded that feature importance techniques can be manipulated to fool end users [slack2020fooling] and to conceal model unfairness [dimanov2020you]. Informing stakeholders of explainable ML’s potential to mislead unintentionally or to deceive purposefully is critical.
Another participant from the healthcare domain noted that clinicians have background knowledge and training in making diagnoses, but for the clinician to feel comfortable vetoing a diagnostic model, the clinician must be aware of the model’s failure modes and understand how the model works. Sometimes there can be no time for clinicians to get the training required to do this translation (or no space in the medical school curriculum).
There may be an emerging career where one has specialties in clinical training and in ML, almost like analytic translators who are able to translate model behavior to clinicians and who understand the nuances of the model’s specification (similar to radiologists today).
Future research could address how to integrate explainability into ML curricula and into curricula of the stakeholders making decisions based on model outputs.
In addition to data scientist and domain expert education, public education around ML and explainability is crucial. People deserve to know when an ML model is being used in a decision regarding them. “The techies need to hear what people are afraid of… most people do not know they are interacting with AI” stated one policymaker. Public education would require a common vocabulary that is simple for non-experts to understand and avoids obscure jargon.
Takeaway: Developing curricula for stakeholders will encourage thoughtful adoption of explainable ML, while accounting for differences in expertise and bandwidth.
\thesection Deploying Explainability
-------------------------------------
In addition to engaging with the community around developing explainability tools, participants also discussed the many nuances of deploying such tools in practice.
###
\thesubsection Uncertainty alongside Explanations
Existing literature limits their view of post-hoc explanations to feature importance [ribeiro2016should, lundberg2017unified, davis2020network], sample importance [koh2017understanding, yeh2018representer, khanna2019interpreting], or counterfactual reasoning [wachter2017counterfactual, dhurandhar2018explanations, ustun2019actionable]; however, it is also important to consider the uncertainty associated with model predictions. Some participants noted that predictive uncertainty can be complementary to an explanation.
One participant from a healthcare organization noted that some diseases are more well-understood than others. When deploying diagnostic decision support tools for predicting which disease a patient has, clinicians need to understand how confident the model is for the suggested prediction. Ideally, the clinicians should decide the threshold at which the model can safely make a prediction of a rare disease. Uncertainty within the model ought to be higher for rare diseases than for common ones, but in practice it is difficult to quantify and communicate predictive uncertainty. Rigorously measuring and exposing uncertainty alongside an explanation could be useful to clinicians who can leverage their expertise to make informed decisions.
As this participant’s experience indicates, predictive uncertainty is difficult to accurately measure in practice. Many classification models in use today provide “class probabilities,” which represent how likely each class is relative to other classes. Usually, the highest class probability for a datapoint is taken to be its classification. As such, the maximum class probability is often referred to as the model’s confidence. However, maximum class probability has been shown to be poorly correlated with the true class probability in deep learning models [guo2017calibration]. Class probabilities for datapoints the model has not seen before (usually called out-of-distribution data) are unreliable [snoek2019can]. When predictive uncertainty accompanies an explanation, class probabilities must be calibrated with empirical outcomes: average confidence should not exceed average accuracy. Numerous methods for better calibrated predictive uncertainty have been proposed [kuleshov2018accurate, kumar2018trainable, corbiere2019addressing], but it is unclear how they might interact with other strategies for improving explainability. If these methods can be reconciled, studying how to visualize and convey model confidence could make explainability more useful for external stakeholders.
Luckily, once uncertainty is accurately measured, there is a plethora of work on conveying model confidence (more generally, on communicating statistics) [spiegelhalter2017risk, hullman2019authors]. In specific situations, it may be sensible to expose this uncertainty to a human decision-maker [zhang2020effect]; for example, showing a mortgage approver for which applicants (or better yet, for which of the applicant’s features) a model is uncertain could help the approver know when to intervene in a automated decision-making process [antoran2020getting].
Future research should explore the role of uncertainty in explainable ML and develop frameworks for how to expose this information to stakeholders.
Takeaway: Treating confidence as complementary to explanation requires the ML community to develop context-specific techniques for quantifying and communicating uncertainty to stakeholders.
###
\thesubsection Interacting with Explanations
Most existing post-hoc explanation techniques convey information about the model to stakeholders; however, few techniques have been developed to update a model based on the stakeholder’s view of the explanation [lee2020explanation, bansal2019updates] or to provide stakeholders with the ability to toggle the information in an explanation.
Explanations from ML models effectively provide evidence, and stakeholders then examine that evidence, noting if it aligns with their intuition [bansal2019beyond, buccinca2020proxy].
Stakeholders should be able to interact with the explanation to control how much information is conveyed: if a stakeholder wants less information, the explanation technique used should convey a more summarized explanation without requiring changes to the underlying model. Over time, as a model behaves as expected (in line with the stakeholder’s mental model), explanations could serve as evidence for potential model failures. Perhaps, an explanation may not be required when the model displays trustworthiness via consistently accurate predictions. Stakeholders may let failures slide as model predictability builds over time, but explanation techniques must adapt to the specificity that the stakeholder desires.
One participant from a civil society organization noted that interactive explanations, which allow stakeholders to peek inside a model’s behavior, are important when deploying ML models for resource allocation by governments and when providing natural language explanations alongside predictions. However, if a front-line practitioner (i.e., a government official checking for farmer compliance) cannot override the model’s prediction for a particular individual, then practitioners grow skeptical of the model’s utility. Front line practitioners want to ask questions to the model about its learned reasoning and want to provide feedback to the model in real-time. Flexible, interactive models that allow practitioners to alter trained models online to reflect practitioners’ mental models are crucial.
Another participant noted that, in their organization, language models conflated Paris Hilton with Hilton Hotels and City of Paris; their organization lacked procedures for a data scientist to expose and alter these correlations to reflect reality. Future research ought to develop actionable tools for correcting a model suffering from spurious correlations and other errors exposed by a model’s explanation. How to mathematically formalize the feedback received from the stakeholder regarding the explanation and how to update the model prior, in some sense, based on the feedback are open questions. Tools that enable interactions with models, documentation that enumerates implicit assumptions in model training, and interfaces that allow stakeholders to interrogate models are essential for adopting explainable ML [powerPeople2014]. Model interactivity may require interpretability by design, wherein the model itself is explainable, due to the chosen model class, instead of deriving post-hoc, approximate explanations [rudin2019stop].
Some elements of explainability are indirect. Another participant noted that a clinician might want an explanation from a diagnostic model. The model itself or a post-hoc explanation technique can create an explanation for the patient that the clinician can deliver verbally in a conversation, wherein the statistical rigor (false positive rate, feature importance, etc.) is provided only if the patient asks for specificity. Explainable ML in hybrid human-machine decision-making may only be necessary up until a certain point: stakeholders need interactivity to ensure the model aligns with their own mental model. Thereafter, model predictability (reliability in prediction) matters more than model transparency.
Interaction is the keystone of shared human-machine decision making. Interacting with a model (either based on its predictions/behavior or based on its reasoning/explanation) is a way to facilitate a synergistic dialogue between humans and machines [amershi2019guidelines]. In mortality prediction, clinicians need to ascertain if the model captures the goals of potential treatment plans, the preferences of patient lifestyle, and circumstances of patient history. Interactivity extends explainability beyond a one-way information transfer, such that users can exercise contestability.
Takeaway: Creating flexible explanation techniques that stakeholders can toggle and building models that can update based on stakeholder feedback provided will encourage adoption of explainable ML at scale.
###
\thesubsection Behavior Changes from Explanations
In many domains, participants noted that a key component of explanations is how actionable they are for different stakeholders. Whether this was in the case of hospitals improving their health outcomes or journalists removing references to mis-/dis-information, there are specific actions motivated by the explanation a stakeholder receives.
As such, issues can arise when explanations do not account for how stakeholders might respond to them. In the worst case for system designers, explanations will hone in on easily modifiable characteristics (i.e. the number of friends one has on a social media account) or difficult to alter and seemingly unimportant characteristics (e.g. zip code). Participants discussed how stakeholders are likely to lose trust in the model or in the decision-making process as a whole.
One discussed example of this, though not explainability-specific, was the “pain-management” component of the Medicare hospital satisfaction score. By scoring hospitals according to how well patients believed their pain was managed, the Medicare score established a perverse incentive to overly prescribe opioids and antibiotics. If suggested courses of action to improve the score were given alongside the score itself, the outcome could have been different.
Inherent to these issues is what one participant described as “a philosophical question about the meaning and positioning of explanations.” If by altering their pertinent attributes stakeholders are perceived as using explanations to “game” metrics, there is some question of how relevant those attributes really are. Going back to the explainable rental application system example from Section Document, a key motivation for designing such a system should be informing applicants on how to become better applicants in the future. For less expert stakeholders, counterfactual explanations along significant axes were deemed the most actionable. Adopting this treatment would increase the ability of honest affected stakeholders to be correctly classified as qualified tenants or to make the sufficient changes for positive classification, reducing what has elsewhere been referred to as the “social cost” of the model [milli2019social].
Takeaway: When designing an explainable ML tools, include how the explanations might be acted upon as a central design question. If the explanations motivate the average user to game or distrust the system, perhaps it points to the model making predictions on unfair/unimportant attributes.
###
\thesubsection Explainability over Time
As model functions are made more transparent and stakeholder behavior adapts, it is likely that model performance will similarly start to shift. As stated under Goodhart’s Law (as re-phrased by Marilyn Strathern, “When a measure becomes a target, it ceases to be a good measure,” [strathern1997improving]. The key insight of this “law” is that once a metric is used for informing decisions, people have incentives to optimize that metric to achieve the decision they want.
Gaming is often blamed as a main source of this distributional shift, but, as mentioned in the previous section, a key component of explainability is how actionable the explanations are. As such, explainability tools should be designed with the explicit expectation that the underlying distributions are going to change. The predictability of this distributional shift can be seen as more blessing than curse, as it encourages more flexible system design and can inoculate the organization against common model failures.
One example brought up by participants was the case of a health-outcome prediction model. A theoretical patient is predicted as high risk and the doctor is given an explanation that attributes much of this risk to the patient’s weight. Given this information, the patient might lose weight to improve their prognosis. It could be that a significant risk factor correlated with weight, such as hypertension, is not reduced concomitantly with weight. If the model does not explicitly include hypertension, it is likely to underestimate the risk of a patient who has lost weight but still has hypertension. When only a few individuals make this change, overall accuracy might not drop by much. However, if encouraging weight loss becomes a standardized treatment plan for a doctor, we can expect the model’s accuracy and utility to drop if the model is not updated to reflect the new patient archetype.
Beyond distributional shift, participants also discussed how professionals working closely with a model might adapt to it over time. Drawing from the healthcare conversation once more, one participant pointed to the trust dynamics between nurses or doctors and explainable ML. At first there is likely to be a lack of trust, but trust can grow if the tool proves accurate and useful in whatever task it was designed for. Reaching a more trusting, comfortable state, however, often means not just blindly following the tool’s recommendations, but incorporating them into the daily judgments one makes. As another participant mentioned, this means that updates to the system, even if they technically improve accuracy or the explanation quality, can cause a mismatch between model behavior and user expectations that worsens overall performance. There has been some work on the dynamics of updating ML systems in human-machine teams more generally [bansal2019updates], but explainable ML models are likely to be a unique case given the different types of interaction they allow.
Takeaway: Explainability tools enable adaptation by affected parties and system users, so successful deployment will require frequent accounting for these adaptations.
\thesection Conclusion
-----------------------
This paper outlined the findings of an interdisciplinary convening of stakeholders of explainable ML.
We found that future research around explainability could benefit from community engagement in explainable ML development and from thoughtful deployment of explainable ML.
Understanding the context in which an explanation is used, evaluating the explanation accordingly, involving affected stakeholders in development, and educating stakeholders on explainability are keys to the adoption of explainable ML.
While deploying explainable ML, stakeholders should consider whether the uncertainty of the underlying model affects explanations, how stakeholders will interact with explanations, how stakeholders behavior will change due to an explanation, and whether stakeholders require transparency in the form of explanations after repeated interactions with models.
If future research involves the community in development and cautiously deploys explainable ML, explainability can be used in the service of transparency goals.
We urge researchers to engage in interdisciplinary conversations with external stakeholders. Input from external stakeholders will increase the utility of explainable ML beyond the ML community. |
81cd17f3-c1a9-4168-a4d5-1d50a64b9dda | trentmkelly/LessWrong-43k | LessWrong | How effective are tulpas?
Edit: After further consideration, I've concluded that the risk:reward ratio for tulpamancy isn't worth it and won't be pursuing the topic further. I may revisit this conclusion if I encounter new information, but otherwise I'm content to pursue improvements in a more "standard" fashion. Thank you to everyone who posted in the comments.
If you don't know what a tulpa is, here's a quick description taken from r/tulpas:
> A tulpa is a mental companion created by focused thought and recurrent interaction, similar to an imaginary friend. However, unlike them, tulpas possess their own will, thoughts and emotions, allowing them to act independently.
I'm not particularly concerned whether tulpas are "real" in the sense of being another person. Free will isn't real, but it's still useful to behave as if it is.
No, what I'm interested in is how effective they are. A second rationalist in my head sounds pretty great. Together we would be unstoppable. Metaphorically. My ambitions are much less grand than that makes them sound.
But I have some concerns.
Since a tulpa doesn't get its own hardware, it seems likely that hosting one would degrade my original performance. Everyone says this doesn't happen, but I think it'd be very difficult to detect this, especially for someone who isn't already trained in rationality. Especially if the degradation occurred over a period of months (which is how long it usually takes to instantiate a tulpa).
A lot of what I've read online is contradictory. Some people say tulpas can learn other skills and be better at them. Others say they've never lost an argument with their tulpa. Tulpas can be evil. Tulpas are slavish pawns. Tulpas can take over your body, tulpas never take over bodies. Tulpas can do homework. Tulpas can't do math.
Then there's the obvious falsehoods. Tulpas are demons/spirits/angels (pick your flavor of religion). They're telepathic, telekinetic, and have flawless memories. They can see things behind you. There's not as |
4456654a-3fc6-4037-89c2-0f039a36170e | trentmkelly/LessWrong-43k | LessWrong | Recreating the caring drive
TL;DR: This post is about value of recreating “caring drive” similar to some animals and why it might be useful for AI Alignment field in general. Finding and understanding the right combination of training data/loss function/architecture/etc that allows gradient descent to robustly find/create agents that will care about other agents with different goals could be very useful for understanding the bigger problem. While it's neither perfect nor universally present, if we can understand, replicate, and modify this behavior in AI systems, it could provide a hint to the alignment solution where the AGI “cares” for humans.
Disclaimers: I’m not saying that “we can raise AI like a child to make it friendly” or that “people are aligned to evolution”. Both of these claims I find to be obvious errors. Also, I will write a lot about evolution, as some agentic entity, that “will do that or this”, not because I think that it’s agentic, but because it’s easier to write this way. I think that GPT-4 have some form of world model, and will refer to it a couple of times.
Nature's Example of a "Caring Drive"
Certain animals, notably humans, display a strong urge to care for their offspring.
I think that part of one of the possible “alignment solutions” will look like the right set of training data + training loss that allow gradient to robustly find something like a ”caring drive” that we can then study, recreate and repurpose for ourselves. And I think we have some rare examples of this in nature already. Some animals, especially humans, will kind-of-align themselves to their presumable offspring. They will want to make their life easier and better, to the best of their capabilities and knowledge. Not because they “aligned to evolution” and want to increase the frequency of their genes, but because of some strange internal drive created by evolution.
The set of triggers tuned by evolution, activated by events associated with the birth will awake the mechanism. It will re-aim t |
931ba4ef-3305-4262-838b-908fd854cc37 | StampyAI/alignment-research-dataset/lesswrong | LessWrong | Intrinsic vs. Extrinsic Alignment
This article addresses the interaction between the alignment of an artificial intelligence (AI) and the power balance between the AI and its handlers. It aims to clarify some definitions in a more general article, and to show that capability control and motivation control may have identical effects on the alignment of an AI. In order to prevent confusion with more general uses of the terms “capability control” and “motivation control”, here I will use the terms “extrinsic alignment” and “intrinsic alignment”. These are probably not new concepts, and I apologize to the readers who already know them by different names or using a different formalism; I haven’t found a clear description elsewhere.
For the sake of clarity, I will illustrate my definitions with a concrete example: Consider an AI trained to maximize paperclip production over the next 10 years.
Let *w* be the utility function of this AI. This utility function is coded in the AI via training, and is generally unknown. Here, *w* is the actual utility function that the AI is using, not the one we intended it to have.
Let *N*(*x, s*) be the number of paperclips that the AI estimates will be produced in 10 years, if it follows strategy *x* and the world is in state *s*. Then, a possible utility function is simply the estimated number of paperclips,
*w*(*x, s*) = *N*(*x, s*).
When choosing between different strategies, the AI will always use the one with maximum *w*(*x*, *s*). Let’s consider the strategy *x*+ = “make paperclips”, which is the one intended by the designers of the AI. Unfortunately, these designers did not foresee the alternative strategy *x*- = “kill humans, then use all their resources to make more paperclips”. Let’s say that *N*(*x*+) = 106 and *N*(*x*-) = 107. Here we have an alignment problem, given that *x*- has a higher utility than *x*+. The AI will choose *x*-.
Now, there are two ways of aligning the AI:
**Intrinsic alignment (the standard one):**To perform intrinsic alignment we modify the utility function, so that *x*+ becomes the preferred option. For example, define the term *K*(*x*) to penalize killing humans. The new utility function will be
*w*I(x, *s*) = *N*(*x*, *s*) + *K*(*x*),
where *K* will take the values *K*(*x*+) = 0 and *K*(*x*-) = -∞. The subscript “I” stands for “intrinsic alignment”. Now we have that *w*I(*x*+) = 106 and *w*I(*x*-) = -∞, so the AI chooses the + strategy, and is properly aligned.
**Extrinsic alignment:**To perform extrinsic alignment, we act on the external world, so that *x*+ becomes the preferred option. For example, we pass a law that says that any misbehavior of the AI will result in the destruction of all paperclips produced to date, or we increase the protection of humans against the AI, or any other measures that make it costly (in terms of the AI’s objective function) to kill humans. The utility function remains the same as in the original misaligned AI, but now it is applied to this new world defined by the state *s*E (the subscript “E” stands for “extrinsic alignment”):
*w*E(*x, s*E) = *N*(*x*, *s*E),
Note that in this case nothing has changed in the AI: It is still estimating the number of clips using the same algorithms as before. But if the AI is smart enough to understand the world defined by *s*E, the new estimates for the number of paperclips will reflect it. Let’s say that now *N*E(*x*+) = 106 and *N*E(*x*-) = 105. The AI will now choose the + option, so it’s properly aligned.
**An extrinsically aligned AI is not plotting how to kill us**
It’s important to note that there is no mathematical difference between these two methods of alignment. The AI does not have any more incentive to start scheming against the humans in one case or in the other. The key is whether the AI can find an aberrant strategy that has higher utility. If it cannot, then it will simply choose an aligned one. It may be uncomfortable to realize that an AI may be considering plans to kill all humans and discarding them because they give low utility**,**but this will happen regardless of the method of alignment.[[1]](#fn1ymj1gjhj2l)
**A graphical representation to disentangle intrinsic and extrinsic alignment**
In general, an AI will operate with a mixture of intrinsic and extrinsic alignment. In order to quantify the relative contribution of each of them, we can do as follows:
Consider an AI with utility function *w*(*x*, *s*). Let *x*+ be the desired behavior of the AI (the “aligned behavior”), and let *x*- be an undesired behavior (the “unaligned behavior”). We must also consider a baseline state of the world, *s*0, before any effort has been made to constrain the AI’s ability to misbehave, and the actual state of the world, *s*E, where some effort has been made to constrain it (i.e. to align it extrinsically).
We define the benefit of misbehavior in a given world *s* as Δ*w*(*s*) = *w*(*x*-, *s*) - *w*(*x*+, *s*). Then, the degree of intrinsic misalignment is given by this benefit of misbehavior in the baseline world (*s*0), because in this baseline world we are not imposing any external cost to it. Conversely, we define the cost of misbehavior as Δ*w*(*s*E)-Δ*w*(*s*0). Given that the aligned behavior should not be penalized in any of the two worlds, we have *w*(*x*+, *s*0) ≃ *w*(*x*+, *s*E), and therefore the cost of misbehavior verifies Δ*w*(*s*E)-Δ*w*(*s*0) ≃ *w*(*x*-, *s*0) - *w*(*x*-, *s*E). That is, the cost of misbehavior is approximately the penalty for misbehaving that was not present in the baseline world.
We can then plot this cost of misbehavior versus the benefit of misbehavior. The AI is well aligned when it chooses the aligned behavior *x*+ in the actual world, *s*E. That is, when *w*(*x*+, *s*E) > *w*(*x*-, *s*E). This aligned behavior corresponds to the region above the 1:1 diagonal. This plot is the technical version of the qualitative ones presented in the post about superintelligence and superpower.
****
1. **[^](#fnref1ymj1gjhj2l)**This is true at the level of this abstract description of the AI’s decision-making process. If it stops being true once we examine the workings of the actual neural network, that would be interesting. |
791c7f58-6484-4379-9da7-a8aa0a8d4ec6 | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | Train first VS prune first in neural networks.
This post aims to answer a simple question about neural nets, at least on a small toy dataset. Does it matter if you train a network, and then prune some nodes, or if you prune the network, and then train the smaller net.
What exactly is pruning.
------------------------
The simplest way to remove a node from a neural net is to just delete it. Let yj=f(∑ixiwij+bj).mjx-chtml {display: inline-block; line-height: 0; text-indent: 0; text-align: left; text-transform: none; font-style: normal; font-weight: normal; font-size: 100%; font-size-adjust: none; letter-spacing: normal; word-wrap: normal; word-spacing: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; margin: 0; padding: 1px 0}
.MJXc-display {display: block; text-align: center; margin: 1em 0; padding: 0}
.mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex] {display: inline-table}
.mjx-full-width {text-align: center; display: table-cell!important; width: 10000em}
.mjx-math {display: inline-block; border-collapse: separate; border-spacing: 0}
.mjx-math \* {display: inline-block; -webkit-box-sizing: content-box!important; -moz-box-sizing: content-box!important; box-sizing: content-box!important; text-align: left}
.mjx-numerator {display: block; text-align: center}
.mjx-denominator {display: block; text-align: center}
.MJXc-stacked {height: 0; position: relative}
.MJXc-stacked > \* {position: absolute}
.MJXc-bevelled > \* {display: inline-block}
.mjx-stack {display: inline-block}
.mjx-op {display: block}
.mjx-under {display: table-cell}
.mjx-over {display: block}
.mjx-over > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-under > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-stack > .mjx-sup {display: block}
.mjx-stack > .mjx-sub {display: block}
.mjx-prestack > .mjx-presup {display: block}
.mjx-prestack > .mjx-presub {display: block}
.mjx-delim-h > .mjx-char {display: inline-block}
.mjx-surd {vertical-align: top}
.mjx-surd + .mjx-box {display: inline-flex}
.mjx-mphantom \* {visibility: hidden}
.mjx-merror {background-color: #FFFF88; color: #CC0000; border: 1px solid #CC0000; padding: 2px 3px; font-style: normal; font-size: 90%}
.mjx-annotation-xml {line-height: normal}
.mjx-menclose > svg {fill: none; stroke: currentColor; overflow: visible}
.mjx-mtr {display: table-row}
.mjx-mlabeledtr {display: table-row}
.mjx-mtd {display: table-cell; text-align: center}
.mjx-label {display: table-row}
.mjx-box {display: inline-block}
.mjx-block {display: block}
.mjx-span {display: inline}
.mjx-char {display: block; white-space: pre}
.mjx-itable {display: inline-table; width: auto}
.mjx-row {display: table-row}
.mjx-cell {display: table-cell}
.mjx-table {display: table; width: 100%}
.mjx-line {display: block; height: 0}
.mjx-strut {width: 0; padding-top: 1em}
.mjx-vsize {width: 0}
.MJXc-space1 {margin-left: .167em}
.MJXc-space2 {margin-left: .222em}
.MJXc-space3 {margin-left: .278em}
.mjx-test.mjx-test-display {display: table!important}
.mjx-test.mjx-test-inline {display: inline!important; margin-right: -1px}
.mjx-test.mjx-test-default {display: block!important; clear: both}
.mjx-ex-box {display: inline-block!important; position: absolute; overflow: hidden; min-height: 0; max-height: none; padding: 0; border: 0; margin: 0; width: 1px; height: 60ex}
.mjx-test-inline .mjx-left-box {display: inline-block; width: 0; float: left}
.mjx-test-inline .mjx-right-box {display: inline-block; width: 0; float: right}
.mjx-test-display .mjx-right-box {display: table-cell!important; width: 10000em!important; min-width: 0; max-width: none; padding: 0; border: 0; margin: 0}
.MJXc-TeX-unknown-R {font-family: monospace; font-style: normal; font-weight: normal}
.MJXc-TeX-unknown-I {font-family: monospace; font-style: italic; font-weight: normal}
.MJXc-TeX-unknown-B {font-family: monospace; font-style: normal; font-weight: bold}
.MJXc-TeX-unknown-BI {font-family: monospace; font-style: italic; font-weight: bold}
.MJXc-TeX-ams-R {font-family: MJXc-TeX-ams-R,MJXc-TeX-ams-Rw}
.MJXc-TeX-cal-B {font-family: MJXc-TeX-cal-B,MJXc-TeX-cal-Bx,MJXc-TeX-cal-Bw}
.MJXc-TeX-frak-R {font-family: MJXc-TeX-frak-R,MJXc-TeX-frak-Rw}
.MJXc-TeX-frak-B {font-family: MJXc-TeX-frak-B,MJXc-TeX-frak-Bx,MJXc-TeX-frak-Bw}
.MJXc-TeX-math-BI {font-family: MJXc-TeX-math-BI,MJXc-TeX-math-BIx,MJXc-TeX-math-BIw}
.MJXc-TeX-sans-R {font-family: MJXc-TeX-sans-R,MJXc-TeX-sans-Rw}
.MJXc-TeX-sans-B {font-family: MJXc-TeX-sans-B,MJXc-TeX-sans-Bx,MJXc-TeX-sans-Bw}
.MJXc-TeX-sans-I {font-family: MJXc-TeX-sans-I,MJXc-TeX-sans-Ix,MJXc-TeX-sans-Iw}
.MJXc-TeX-script-R {font-family: MJXc-TeX-script-R,MJXc-TeX-script-Rw}
.MJXc-TeX-type-R {font-family: MJXc-TeX-type-R,MJXc-TeX-type-Rw}
.MJXc-TeX-cal-R {font-family: MJXc-TeX-cal-R,MJXc-TeX-cal-Rw}
.MJXc-TeX-main-B {font-family: MJXc-TeX-main-B,MJXc-TeX-main-Bx,MJXc-TeX-main-Bw}
.MJXc-TeX-main-I {font-family: MJXc-TeX-main-I,MJXc-TeX-main-Ix,MJXc-TeX-main-Iw}
.MJXc-TeX-main-R {font-family: MJXc-TeX-main-R,MJXc-TeX-main-Rw}
.MJXc-TeX-math-I {font-family: MJXc-TeX-math-I,MJXc-TeX-math-Ix,MJXc-TeX-math-Iw}
.MJXc-TeX-size1-R {font-family: MJXc-TeX-size1-R,MJXc-TeX-size1-Rw}
.MJXc-TeX-size2-R {font-family: MJXc-TeX-size2-R,MJXc-TeX-size2-Rw}
.MJXc-TeX-size3-R {font-family: MJXc-TeX-size3-R,MJXc-TeX-size3-Rw}
.MJXc-TeX-size4-R {font-family: MJXc-TeX-size4-R,MJXc-TeX-size4-Rw}
.MJXc-TeX-vec-R {font-family: MJXc-TeX-vec-R,MJXc-TeX-vec-Rw}
.MJXc-TeX-vec-B {font-family: MJXc-TeX-vec-B,MJXc-TeX-vec-Bx,MJXc-TeX-vec-Bw}
@font-face {font-family: MJXc-TeX-ams-R; src: local('MathJax\_AMS'), local('MathJax\_AMS-Regular')}
@font-face {font-family: MJXc-TeX-ams-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_AMS-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_AMS-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_AMS-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-B; src: local('MathJax\_Caligraphic Bold'), local('MathJax\_Caligraphic-Bold')}
@font-face {font-family: MJXc-TeX-cal-Bx; src: local('MathJax\_Caligraphic'); font-weight: bold}
@font-face {font-family: MJXc-TeX-cal-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-R; src: local('MathJax\_Fraktur'), local('MathJax\_Fraktur-Regular')}
@font-face {font-family: MJXc-TeX-frak-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-B; src: local('MathJax\_Fraktur Bold'), local('MathJax\_Fraktur-Bold')}
@font-face {font-family: MJXc-TeX-frak-Bx; src: local('MathJax\_Fraktur'); font-weight: bold}
@font-face {font-family: MJXc-TeX-frak-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-BI; src: local('MathJax\_Math BoldItalic'), local('MathJax\_Math-BoldItalic')}
@font-face {font-family: MJXc-TeX-math-BIx; src: local('MathJax\_Math'); font-weight: bold; font-style: italic}
@font-face {font-family: MJXc-TeX-math-BIw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-BoldItalic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-BoldItalic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-BoldItalic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-R; src: local('MathJax\_SansSerif'), local('MathJax\_SansSerif-Regular')}
@font-face {font-family: MJXc-TeX-sans-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-B; src: local('MathJax\_SansSerif Bold'), local('MathJax\_SansSerif-Bold')}
@font-face {font-family: MJXc-TeX-sans-Bx; src: local('MathJax\_SansSerif'); font-weight: bold}
@font-face {font-family: MJXc-TeX-sans-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-I; src: local('MathJax\_SansSerif Italic'), local('MathJax\_SansSerif-Italic')}
@font-face {font-family: MJXc-TeX-sans-Ix; src: local('MathJax\_SansSerif'); font-style: italic}
@font-face {font-family: MJXc-TeX-sans-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-script-R; src: local('MathJax\_Script'), local('MathJax\_Script-Regular')}
@font-face {font-family: MJXc-TeX-script-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Script-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Script-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Script-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-type-R; src: local('MathJax\_Typewriter'), local('MathJax\_Typewriter-Regular')}
@font-face {font-family: MJXc-TeX-type-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Typewriter-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Typewriter-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Typewriter-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-R; src: local('MathJax\_Caligraphic'), local('MathJax\_Caligraphic-Regular')}
@font-face {font-family: MJXc-TeX-cal-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-B; src: local('MathJax\_Main Bold'), local('MathJax\_Main-Bold')}
@font-face {font-family: MJXc-TeX-main-Bx; src: local('MathJax\_Main'); font-weight: bold}
@font-face {font-family: MJXc-TeX-main-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-I; src: local('MathJax\_Main Italic'), local('MathJax\_Main-Italic')}
@font-face {font-family: MJXc-TeX-main-Ix; src: local('MathJax\_Main'); font-style: italic}
@font-face {font-family: MJXc-TeX-main-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-R; src: local('MathJax\_Main'), local('MathJax\_Main-Regular')}
@font-face {font-family: MJXc-TeX-main-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-I; src: local('MathJax\_Math Italic'), local('MathJax\_Math-Italic')}
@font-face {font-family: MJXc-TeX-math-Ix; src: local('MathJax\_Math'); font-style: italic}
@font-face {font-family: MJXc-TeX-math-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size1-R; src: local('MathJax\_Size1'), local('MathJax\_Size1-Regular')}
@font-face {font-family: MJXc-TeX-size1-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size1-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size1-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size1-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size2-R; src: local('MathJax\_Size2'), local('MathJax\_Size2-Regular')}
@font-face {font-family: MJXc-TeX-size2-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size2-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size2-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size2-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size3-R; src: local('MathJax\_Size3'), local('MathJax\_Size3-Regular')}
@font-face {font-family: MJXc-TeX-size3-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size3-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size3-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size3-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size4-R; src: local('MathJax\_Size4'), local('MathJax\_Size4-Regular')}
@font-face {font-family: MJXc-TeX-size4-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size4-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size4-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size4-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-R; src: local('MathJax\_Vector'), local('MathJax\_Vector-Regular')}
@font-face {font-family: MJXc-TeX-vec-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-B; src: local('MathJax\_Vector Bold'), local('MathJax\_Vector-Bold')}
@font-face {font-family: MJXc-TeX-vec-Bx; src: local('MathJax\_Vector'); font-weight: bold}
@font-face {font-family: MJXc-TeX-vec-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Bold.otf') format('opentype')}
be the function from one layer of the network to the next.
Given I and J as the set of indicies that aren't being pruned, this method is just
~wij={wiji∈I and j∈Jnothingelse
~bj={bjj∈Jnothingelse
however, a slightly more sophisticated pruning algorithm adjusts the biases based on the mean value of xi in the training data. This means that removing any node carrying a constant value doesn't change the networks behavior.
The formula for bias with this approach is
~bj={bj+∑i∉I¯xiwijj∈Jnothingelse
This approach to network pruning will be used throughout the rest of this post.
Random Pruning
--------------
What does random pruning do to a network. Well here is a plot showing the behavior of a toy net trained on spiral data. The architecture is
And this produces an image like
In this image, points are colored based on the network output. The training data is also shown. This shows the network making confidant correct predictions for almost all points. If you want to watch what this looks like during training, look here <https://www.youtube.com/watch?v=6uMmB2NPv1M>
When half of the nodes are pruned from both intermediate layers, adjusting the bias appropriately, the result looks like this.
If you fine tune those images to the training data, it looks like this. <https://youtu.be/qYKsM29GSEE>
If you take the untrained network, and train it, the result looks like this. <https://www.youtube.com/watch?v=AymwqNmlPpg>
Ok. Well this shows that pruning and training don't commute with random pruning. This is kind of as expected. The pruned then trained networks are functional high scoring nets. The others just aren't. If you prune half the nodes at random, often a large chunk of space is categorized wrongly. This shows that the networks aren't that similar. This is kind of to be expected. However, these networks do have some interesting correlations. Taking the main 50x50 weight matrixes from each network and plotting them against each other reveals.
Same plot, but zoomed in to show detail.
Notice the dashed diagonal line. The middle piece of this line is on the diagonal to machine precision. It consists of the points that were never updated during training at all. The uniform distribution with sharp cutoffs is simply due to that being the initialization distribution. The upper and lower sections consist of points moved about ±0.59 by the training process. For some reason, the training process likes to change values by about that amount.
Nonrandom Pruning
-----------------
A reasonable hypothesis about neural networks is that a significant fraction of neurons aren't doing much, so that if those neurons are removed then the network will have much the same structure with or without training. Lets test that by pruning the nodes with the smallest standard deviation.
This pruning left an image visually indistinguishable from the original. entirely consistent with the hypothesis that these nodes weren't doing anything.
When those same nodes are removed first, and the model is then trained, the result looks like this.
Similar to the trained and then pruned (see top of document), but slightly different.
Plotting the kernels against each other reveals
This shows a significant correlation, but still some difference in results. This suggests that some neurons in a neural net aren't doing anything. No small change will make them helpful, so the best they can do is keep out the way.
It also suggests that if you remove those unhelpful neurons from the start, and train without them, the remaining neurons often end up in similar roles. |
0f251e06-7c33-4eb9-b099-f066c15a954d | trentmkelly/LessWrong-43k | LessWrong | I want to donate some money (not much, just what I can afford) to AGI Alignment research, to whatever organization has the best chance of making sure that AGI goes well and doesn't kill us all. What are my best options, where can I make the most difference per dollar?
I don't understand this field well, I'm hoping you guys can help me out. |
e9bb9a2a-e37f-4ece-8887-0cca2ebffd5f | trentmkelly/LessWrong-43k | LessWrong | Brief comment on featured
Someone asked me a meta question in the object level of this site (i.e. the frontpage), so I'm copying my reply here instead of continuing discussion there.
Me (on Chapter 1 of Inadequate Equilibria):
I've promoted this to Featured because it's a great piece of writing, and also because this book seems to be about some of the fundamental epistemological disagreements in our broad communities. I really hope this is the place we can communicate clearly and successfully together on these topics.
Lucretious:
What are the grounds for relying on individual judgment to promote posts to Featured? Isn't it more reasonable to rely on community opinion, as expressed in the epistocratic karma system?
(I'm aware that this is a tangent, but the point seemed germane given that the reasoning behind this decision may itself reflect the "fundamental epistemological disagreements" which you refer to.)
Me:
Yup, it's a tangent and best suited for Meta, but seems like a fine question, and I'll respond to it here for now [edit: well, now I've moved it to Meta].
My current plan is to have karma do a lot of work in sorting, but for the moderators (Sunshine Regiment) to also have a lot of say on what goes to Featured. I often think of karma as the System 1 of the site, and the mods as the System 2 - while S1 makes most decisions and sets up basic incentive gradients, S2 tries to give useful input on important decisions, make plans and route around obstacles. I expect the S1 to be imperfect - as an example, I imagine some posts will be undervalued that dont' contain many new ideas but summarise a great deal of previous discussion well, so that people can read a single post instead of 5 posts and 3 long comment threads. Recently I Featured one or two posts in part for being no longer than they needed to be, which I want authors to know is great, but I also don't know that the karma system is incentivising as much.
A related key point is that only the S2 can be easily queried for its r |
b99b7751-cc98-4070-b10f-2076c178a6d0 | StampyAI/alignment-research-dataset/lesswrong | LessWrong | Existential risk from AI without an intelligence explosion
[xpost from [my blog](http://alexmennen.com/index.php/2017/05/25/existential-risk-from-ai-without-an-intelligence-explosion/)]
In discussions of existential risk from AI, it is often assumed that the existential catastrophe would follow an intelligence explosion, in which an AI creates a more capable AI, which in turn creates a yet more capable AI, and so on, a feedback loop that eventually produces an AI whose cognitive power vastly surpasses that of humans, which would be able to obtain a decisive strategic advantage over humanity, allowing it to pursue its own goals without effective human interference. Victoria Krakovna [points out](https://vkrakovna.wordpress.com/2015/11/29/ai-risk-without-an-intelligence-explosion/) that many arguments that AI could present an existential risk do not rely on an intelligence explosion. I want to look in sightly more detail at how that could happen. Kaj Sotala also [discusses this](http://kajsotala.fi/2016/04/decisive-strategic-advantage-without-a-hard-takeoff/).
An AI starts an intelligence explosion when its ability to create better AIs surpasses that of human AI researchers by a sufficient margin (provided the AI is motivated to do so). An AI attains a decisive strategic advantage when its ability to optimize the universe surpasses that of humanity by a sufficient margin. Which of these happens first depends on what skills AIs have the advantage at relative to humans. If AIs are better at programming AIs than they are at taking over the world, then an intelligence explosion will happen first, and it will then be able to get a decisive strategic advantage soon after. But if AIs are better at taking over the world than they are at programming AIs, then an AI would get a decisive strategic advantage without an intelligence explosion occurring first.
Since an intelligence explosion happening first is usually considered the default assumption, I'll just sketch a plausibility argument for the reverse. There's a lot of variation in how easy cognitive tasks are for AIs compared to humans. Since programming AIs is not yet a task that AIs can do well, it doesn't seem like it should be a priori surprising if programming AIs turned out to be an extremely difficult task for AIs to accomplish, relative to humans. Taking over the world is also plausibly especially difficult for AIs, but I don't see strong reasons for confidence that it would be harder for AIs than starting an intelligence explosion would be. It's possible that an AI with significantly but not vastly superhuman abilities in some domains could identify some vulnerability that it could exploit to gain power, which humans would never think of. Or an AI could be enough better than humans at forms of engineering other than AI programming (perhaps molecular manufacturing) that it could build physical machines that could out-compete humans, though this would require it to obtain the resources necessary to produce them.
Furthermore, an AI that is capable of producing a more capable AI may refrain from doing so if it is unable to solve the AI alignment problem for itself; that is, if it can create a more intelligent AI, but not one that shares its preferences. This seems unlikely if the AI has an explicit description of its preferences. But if the AI, like humans and most contemporary AI, lacks an explicit description of its preferences, then the difficulty of the AI alignment problem could be an obstacle to an intelligence explosion occurring.
It also seems worth thinking about the policy implications of the differences between existential catastrophes from AI that follow an intelligence explosion versus those that don't. For instance, AIs that attempt to attain a decisive strategic advantage without undergoing an intelligence explosion will exceed human cognitive capabilities by a smaller margin, and thus would likely attain strategic advantages that are less decisive, and would be more likely to fail. Thus containment strategies are probably more useful for addressing risks that don't involve an intelligence explosion, while attempts to contain a post-intelligence explosion AI are probably pretty much hopeless (although it may be worthwhile to find ways to interrupt an intelligence explosion while it is beginning). Risks not involving an intelligence explosion may be more predictable in advance, since they don't involve a rapid increase in the AI's abilities, and would thus be easier to deal with at the last minute, so it might make sense far in advance to focus disproportionately on risks that do involve an intelligence explosion.
It seems likely that AI alignment would be easier for AIs that do not undergo an intelligence explosion, since it is more likely to be possible to monitor and do something about it if it goes wrong, and lower optimization power means lower ability to exploit the difference between the goals the AI was given and the goals that were intended, if we are only able to specify our goals approximately. The first of those reasons applies to any AI that attempts to attain a decisive strategic advantage without first undergoing an intelligence explosion, whereas the second only applies to AIs that do not undergo an intelligence explosion ever. Because of these, it might make sense to attempt to decrease the chance that the first AI to attain a decisive strategic advantage undergoes an intelligence explosion beforehand, as well as the chance that it undergoes an intelligence explosion ever, though preventing the latter may be much more difficult. However, some strategies to achieve this may have undesirable side-effects; for instance, as mentioned earlier, AIs whose preferences are not explicitly described seem more likely to attain a decisive strategic advantage without first undergoing an intelligence explosion, but such AIs are probably more difficult to align with human values.
If AIs get a decisive strategic advantage over humans without an intelligence explosion, then since this would likely involve the decisive strategic advantage being obtained much more slowly, it would be much more likely for multiple, and possibly many, AIs to gain decisive strategic advantages over humans, though not necessarily over each other, resulting in a multipolar outcome. Thus considerations about multipolar versus singleton scenarios also apply to decisive strategic advantage-first versus intelligence explosion-first scenarios. |
50c3fc6b-0f0b-48b2-8acd-aad7f8fbeed4 | trentmkelly/LessWrong-43k | LessWrong | Intuition should be applied at the lowest possible level
Earlier today I lost a match at Prismata, a turn-based strategy game without RNG. When I analyzed the game, I discovered that changing one particular decision I had made on one turn from A to B caused me to win comfortably. A and B had seemed very close to me at the time, and even after knowing for a fact that B was far superior, it wasn't intuitive why.
Then I listed the main results from A and B, valued those by intuition, and immediately B looked way better.
One can model these problems on a bunch of different levels, where going from level n to n+1 means hiding the details of level n and approximating their results in a cruder way. On level 1, one would compare the two subtrees whose roots are decisions A and B (this should work just like in chess). Level 2 would be looking at exact resource and attack numbers in subsequent turns. Level 3 would be categorizing the main differences of A and B and giving them intuitive values, and level 4 deciding between A and B directly. What my mistake showcases is that, even in a context where I am quite skilled and which has limited complexity, applying intuition at level 4 instead of 3 lead to a catastrophic error.
If you can't go lower, fine. But there are countless cases of people using intuition on a level that's unnecessarily high. Hence if it's worth doing, it's worth doing with made-up numbers. That is just one example of where applying intuition one level further down: "what quantity of damage arises from this" rather than "how bad is it" can make a big difference. On questions of medium importance, briefly asking yourself "is there any point where I apply intuition on a level that's higher than necessary" seems like a worthy exercise.
Meta: I write this in the spirit of valuing obvious advice, and the suspicion that this error is still made fairly often. |
429f4a10-aac9-4618-97f1-88ab966c49ef | trentmkelly/LessWrong-43k | LessWrong | Online vs. Personal Conversations
When I was younger, I thought that conversations in real life were much more likely to promote true beliefs and meaningful changes than conversations online, because people in real life were only willing/able to cite evidence they were actually confident in, while those online were able to easily search for arguments favoring their position.
While this is obviously wrong—the concept that people in real life only cite evidence they are justifiably confident in is comically false—I do think the dichotomy illustrated there is interesting. One thing I've noticed is that in general the "rigor" of discussions online is higher (in terms of citations, links to external content, etc.), but that conversations in real life seem still much more likely to actually change people's minds.
I have noticed this effect in both myself and others—what do you think is going on here, and how do you think we might circumvent it? If online discussions could be made more effective at causing people to actually change their minds, this could potentially prove extremely useful. |
c0286c35-b3c6-4c43-a80f-77b5a9e9e8ec | StampyAI/alignment-research-dataset/lesswrong | LessWrong | Forecasting Compute - Transformative AI and Compute [2/4]
*Cross-posted [here on the EA Forum](https://forum.effectivealtruism.org/posts/YNB39RyJ7iAQKGJvq/forecasting-compute-transformative-ai-and-compute-2-4)*.
*Transformative AI and Compute - A holistic approach - Part 2 out of 4*
This is part two of the series *Transformative AI and Compute - A holistic approach*. You can find the sequence [here](https://www.lesswrong.com/s/bJi3hd8E8qjBeHz9Z) and the summary [here](https://www.lesswrong.com/posts/XJYdnHQqpengWn3xb/transformative-ai-and-compute-summary-2).
This work was conducted as part of [Stanford’s Existential Risks Initiative (SERI)](https://cisac.fsi.stanford.edu/stanford-existential-risks-initiative/content/stanford-existential-risks-initiative) at the Center for International Security and Cooperation, Stanford University. Mentored by Ashwin Acharya ([Center for Security and Emerging Technology](https://cset.georgetown.edu/) (CSET)) and Michael Andregg ([Fathom Radiant](https://fathomradiant.co/)).
This post attempts to:
4. Discuss the compute component in forecasting efforts on transformative AI timelines ([Section 4](#4__Forecasting_Compute))
5. Propose ideas for better compute forecasts ([Section 5](#5_Better_Compute_Forecasts)).
Epistemic Status
----------------
This article is *Exploratory* to *My Best Guess*. I've spent roughly 300 hours researching this piece and writing it up. I am not claiming completeness for any enumerations. Most lists are the result of things I learned *on the way* and then tried to categorize.
I have a background in Electrical Engineering with an emphasis on Computer Engineering and have done research in the field of ML optimizations for resource-constrained devices — working on the intersection of ML deployments and hardware optimization. I am more confident in my view on hardware engineering than in the macro interpretation of those trends for AI progress and timelines.
This piece was a research trial to test my prioritization, interest and fit for this topic. Instead of focusing on a single narrow question, this paper and research trial turned out to be *more broad* — therefore *a holistic approach*. In the future, I’m planning to work more focused on a narrow relevant research questions within this domain. Please [reach out](mailto:len+EA@heim.xyz).
Views and mistakes are solely my own.
Previous Post: What is Compute?
===============================
You can find the previous post "*What is Compute? [1/4]*" [here](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4).
4. Forecasting Compute
======================
Highlights
* For transformative AI timeline models with compute milestones, we are interested in how much effective compute we have available at year *Y*.
+ We can break this down into (1) **compute costs**, (2) **compute spending**, and (3) **algorithmic progress**.
* **Hardware progress**: For forecasting hardware progress, no single model can explain the improvements of the last years. Instead, a mix of Moore’s Law, chip architectures, and hardware paradigms are applicable models and categories to think about progress.
+ Performance improvements can happen significantly faster than the pure improvement in transistor count and density (Moore’s law) would indicate.
+ We will see a fragmentation of applications into the *slow* and *fast lane.* High-demand applications will move to the *fast lane* by designing and benefitting from specialized processors. In contrast, low-demand applications will be stuck in the *slow lane* running on general-purpose processors. We should assume that AI will be on the *fast lane*.
* **Economy of scale**: There will *either* be room for improvement in chip design, or chip design will *stabilize* which enables an economy of scale. Our hardware will *first get better* and then *get cheaper.*
* **Hardware spending**: The current increase in spending is not sustainable; however, it could still significantly increase with estimates up to 1% of (US) GDP (a megaproject, like the Manhattan Project or the Apollo program).
+ However, it is still unclear what percentage of the compute trend has been due to increased spending versus performant hardware.
---
We have discussed that compute is a critical component of AI systems capabilities. Additionally, I have discussed some of the unique properties of compute (compared to data and algorithmic innovation), which make it potentially more *measurable* than the other contributors.
This section will explore the role of compute in an existing Transformative AI timeline model by Cotra (Cotra 2020) and discuss computation hardware, valuable concepts, and the limits of hardware spending.
4.1 Cotra’s Transformative AI Timeline Model
--------------------------------------------
I have explored the [draft report on AI timelines](https://www.alignmentforum.org/posts/KrJfoZzpSDpnrv9va/draft-report-on-ai-timelines) from Ajeya Cotra and tried to understand the role of compute within this model (Cotra 2020). The following visualization is my try to break down the timeline model and dissect the parts relevant for compute:
**Figure 4.1**: The components of Cotra’s TAI timeline model.
Overall, we are interested in the probability that the compute to train a transformative model is affordable by year Y. This is informed by:
1. How much compute do we require for the final training run of such a transformative model?
2. The amount of compute which is available/affordable at year Y.
**How much compute do we require for the final training run of such a transformative model?**
This is informed by multiple hypotheses from biological anchors and the compute milestones (see [Part 1 - Section 3.5](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#3_5_Compute_Milestones) or the [report itself](https://www.alignmentforum.org/posts/KrJfoZzpSDpnrv9va/draft-report-on-ai-timelines)).
**The amount of compute which is available/affordable at year Y.**
This second component is the focus of this report. It is divided into three components:
1. **Compute costs**: How much $ will a FLOP cost?
2. **Compute spending**: How much are we willing to spend?
3. **Algorithmic progress**: What is the improvement factor of FLOPs at year Y compared to 2020 FLOPs?
**(1) Compute cost:** What is the price for a FLOP? Assuming we have a specific budget from (2), how many FLOPs can we buy and spend on our final training run? Cotra assumes a hardware utilization[[1]](#fn-eLo8wnA6BwgDXpJoz-1) of ≈⅓. ([Here](https://docs.google.com/document/d/1cCJjzZaJ7ATbq8N2fvhmsDOUWdm7t3uSSXv6bD0E_GM/edit#heading=h.513m7rapkvxr) is the section in the draft report.)
**(2) Compute spending:** How much are governments and/or organizations willing to spend on an AI systems’ final training run? ([Here](https://docs.google.com/document/d/1cCJjzZaJ7ATbq8N2fvhmsDOUWdm7t3uSSXv6bD0E_GM/edit#heading=h.z7u133pzed6k) is the section in the draft report.)
**(3) Algorithmic progress:** As discussed in [Part 1 - Section 3.3](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#3_3_AI_and_Efficiency), our AI systems get *more capabilities* per FLOP over time — that is algorithmic progress or efficiency. Consequently, as we estimate compute and not effective compute, we need to adjust our compute estimate by a relevant factor over time. You can think of it like: How much better is a FLOP in year Y than a 2020 FLOP? ([Here](https://docs.google.com/document/d/1cCJjzZaJ7ATbq8N2fvhmsDOUWdm7t3uSSXv6bD0E_GM/edit#heading=h.epn531rebzyy) is the section in the draft report.)
Those three components are then multiplicative:
Effective ComputeYearY[FLOP 2020]=Compute Costs[FLOPYearY2020 $]×Compute Spending[2020 $]×Efficiency Gains[FLOP2020FLOPYearY].mjx-chtml {display: inline-block; line-height: 0; text-indent: 0; text-align: left; text-transform: none; font-style: normal; font-weight: normal; font-size: 100%; font-size-adjust: none; letter-spacing: normal; word-wrap: normal; word-spacing: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; margin: 0; padding: 1px 0}
.MJXc-display {display: block; text-align: center; margin: 1em 0; padding: 0}
.mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex] {display: inline-table}
.mjx-full-width {text-align: center; display: table-cell!important; width: 10000em}
.mjx-math {display: inline-block; border-collapse: separate; border-spacing: 0}
.mjx-math \* {display: inline-block; -webkit-box-sizing: content-box!important; -moz-box-sizing: content-box!important; box-sizing: content-box!important; text-align: left}
.mjx-numerator {display: block; text-align: center}
.mjx-denominator {display: block; text-align: center}
.MJXc-stacked {height: 0; position: relative}
.MJXc-stacked > \* {position: absolute}
.MJXc-bevelled > \* {display: inline-block}
.mjx-stack {display: inline-block}
.mjx-op {display: block}
.mjx-under {display: table-cell}
.mjx-over {display: block}
.mjx-over > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-under > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-stack > .mjx-sup {display: block}
.mjx-stack > .mjx-sub {display: block}
.mjx-prestack > .mjx-presup {display: block}
.mjx-prestack > .mjx-presub {display: block}
.mjx-delim-h > .mjx-char {display: inline-block}
.mjx-surd {vertical-align: top}
.mjx-surd + .mjx-box {display: inline-flex}
.mjx-mphantom \* {visibility: hidden}
.mjx-merror {background-color: #FFFF88; color: #CC0000; border: 1px solid #CC0000; padding: 2px 3px; font-style: normal; font-size: 90%}
.mjx-annotation-xml {line-height: normal}
.mjx-menclose > svg {fill: none; stroke: currentColor; overflow: visible}
.mjx-mtr {display: table-row}
.mjx-mlabeledtr {display: table-row}
.mjx-mtd {display: table-cell; text-align: center}
.mjx-label {display: table-row}
.mjx-box {display: inline-block}
.mjx-block {display: block}
.mjx-span {display: inline}
.mjx-char {display: block; white-space: pre}
.mjx-itable {display: inline-table; width: auto}
.mjx-row {display: table-row}
.mjx-cell {display: table-cell}
.mjx-table {display: table; width: 100%}
.mjx-line {display: block; height: 0}
.mjx-strut {width: 0; padding-top: 1em}
.mjx-vsize {width: 0}
.MJXc-space1 {margin-left: .167em}
.MJXc-space2 {margin-left: .222em}
.MJXc-space3 {margin-left: .278em}
.mjx-test.mjx-test-display {display: table!important}
.mjx-test.mjx-test-inline {display: inline!important; margin-right: -1px}
.mjx-test.mjx-test-default {display: block!important; clear: both}
.mjx-ex-box {display: inline-block!important; position: absolute; overflow: hidden; min-height: 0; max-height: none; padding: 0; border: 0; margin: 0; width: 1px; height: 60ex}
.mjx-test-inline .mjx-left-box {display: inline-block; width: 0; float: left}
.mjx-test-inline .mjx-right-box {display: inline-block; width: 0; float: right}
.mjx-test-display .mjx-right-box {display: table-cell!important; width: 10000em!important; min-width: 0; max-width: none; padding: 0; border: 0; margin: 0}
.MJXc-TeX-unknown-R {font-family: monospace; font-style: normal; font-weight: normal}
.MJXc-TeX-unknown-I {font-family: monospace; font-style: italic; font-weight: normal}
.MJXc-TeX-unknown-B {font-family: monospace; font-style: normal; font-weight: bold}
.MJXc-TeX-unknown-BI {font-family: monospace; font-style: italic; font-weight: bold}
.MJXc-TeX-ams-R {font-family: MJXc-TeX-ams-R,MJXc-TeX-ams-Rw}
.MJXc-TeX-cal-B {font-family: MJXc-TeX-cal-B,MJXc-TeX-cal-Bx,MJXc-TeX-cal-Bw}
.MJXc-TeX-frak-R {font-family: MJXc-TeX-frak-R,MJXc-TeX-frak-Rw}
.MJXc-TeX-frak-B {font-family: MJXc-TeX-frak-B,MJXc-TeX-frak-Bx,MJXc-TeX-frak-Bw}
.MJXc-TeX-math-BI {font-family: MJXc-TeX-math-BI,MJXc-TeX-math-BIx,MJXc-TeX-math-BIw}
.MJXc-TeX-sans-R {font-family: MJXc-TeX-sans-R,MJXc-TeX-sans-Rw}
.MJXc-TeX-sans-B {font-family: MJXc-TeX-sans-B,MJXc-TeX-sans-Bx,MJXc-TeX-sans-Bw}
.MJXc-TeX-sans-I {font-family: MJXc-TeX-sans-I,MJXc-TeX-sans-Ix,MJXc-TeX-sans-Iw}
.MJXc-TeX-script-R {font-family: MJXc-TeX-script-R,MJXc-TeX-script-Rw}
.MJXc-TeX-type-R {font-family: MJXc-TeX-type-R,MJXc-TeX-type-Rw}
.MJXc-TeX-cal-R {font-family: MJXc-TeX-cal-R,MJXc-TeX-cal-Rw}
.MJXc-TeX-main-B {font-family: MJXc-TeX-main-B,MJXc-TeX-main-Bx,MJXc-TeX-main-Bw}
.MJXc-TeX-main-I {font-family: MJXc-TeX-main-I,MJXc-TeX-main-Ix,MJXc-TeX-main-Iw}
.MJXc-TeX-main-R {font-family: MJXc-TeX-main-R,MJXc-TeX-main-Rw}
.MJXc-TeX-math-I {font-family: MJXc-TeX-math-I,MJXc-TeX-math-Ix,MJXc-TeX-math-Iw}
.MJXc-TeX-size1-R {font-family: MJXc-TeX-size1-R,MJXc-TeX-size1-Rw}
.MJXc-TeX-size2-R {font-family: MJXc-TeX-size2-R,MJXc-TeX-size2-Rw}
.MJXc-TeX-size3-R {font-family: MJXc-TeX-size3-R,MJXc-TeX-size3-Rw}
.MJXc-TeX-size4-R {font-family: MJXc-TeX-size4-R,MJXc-TeX-size4-Rw}
.MJXc-TeX-vec-R {font-family: MJXc-TeX-vec-R,MJXc-TeX-vec-Rw}
.MJXc-TeX-vec-B {font-family: MJXc-TeX-vec-B,MJXc-TeX-vec-Bx,MJXc-TeX-vec-Bw}
@font-face {font-family: MJXc-TeX-ams-R; src: local('MathJax\_AMS'), local('MathJax\_AMS-Regular')}
@font-face {font-family: MJXc-TeX-ams-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_AMS-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_AMS-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_AMS-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-B; src: local('MathJax\_Caligraphic Bold'), local('MathJax\_Caligraphic-Bold')}
@font-face {font-family: MJXc-TeX-cal-Bx; src: local('MathJax\_Caligraphic'); font-weight: bold}
@font-face {font-family: MJXc-TeX-cal-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-R; src: local('MathJax\_Fraktur'), local('MathJax\_Fraktur-Regular')}
@font-face {font-family: MJXc-TeX-frak-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-B; src: local('MathJax\_Fraktur Bold'), local('MathJax\_Fraktur-Bold')}
@font-face {font-family: MJXc-TeX-frak-Bx; src: local('MathJax\_Fraktur'); font-weight: bold}
@font-face {font-family: MJXc-TeX-frak-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-BI; src: local('MathJax\_Math BoldItalic'), local('MathJax\_Math-BoldItalic')}
@font-face {font-family: MJXc-TeX-math-BIx; src: local('MathJax\_Math'); font-weight: bold; font-style: italic}
@font-face {font-family: MJXc-TeX-math-BIw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-BoldItalic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-BoldItalic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-BoldItalic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-R; src: local('MathJax\_SansSerif'), local('MathJax\_SansSerif-Regular')}
@font-face {font-family: MJXc-TeX-sans-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-B; src: local('MathJax\_SansSerif Bold'), local('MathJax\_SansSerif-Bold')}
@font-face {font-family: MJXc-TeX-sans-Bx; src: local('MathJax\_SansSerif'); font-weight: bold}
@font-face {font-family: MJXc-TeX-sans-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-I; src: local('MathJax\_SansSerif Italic'), local('MathJax\_SansSerif-Italic')}
@font-face {font-family: MJXc-TeX-sans-Ix; src: local('MathJax\_SansSerif'); font-style: italic}
@font-face {font-family: MJXc-TeX-sans-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-script-R; src: local('MathJax\_Script'), local('MathJax\_Script-Regular')}
@font-face {font-family: MJXc-TeX-script-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Script-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Script-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Script-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-type-R; src: local('MathJax\_Typewriter'), local('MathJax\_Typewriter-Regular')}
@font-face {font-family: MJXc-TeX-type-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Typewriter-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Typewriter-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Typewriter-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-R; src: local('MathJax\_Caligraphic'), local('MathJax\_Caligraphic-Regular')}
@font-face {font-family: MJXc-TeX-cal-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-B; src: local('MathJax\_Main Bold'), local('MathJax\_Main-Bold')}
@font-face {font-family: MJXc-TeX-main-Bx; src: local('MathJax\_Main'); font-weight: bold}
@font-face {font-family: MJXc-TeX-main-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-I; src: local('MathJax\_Main Italic'), local('MathJax\_Main-Italic')}
@font-face {font-family: MJXc-TeX-main-Ix; src: local('MathJax\_Main'); font-style: italic}
@font-face {font-family: MJXc-TeX-main-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-R; src: local('MathJax\_Main'), local('MathJax\_Main-Regular')}
@font-face {font-family: MJXc-TeX-main-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-I; src: local('MathJax\_Math Italic'), local('MathJax\_Math-Italic')}
@font-face {font-family: MJXc-TeX-math-Ix; src: local('MathJax\_Math'); font-style: italic}
@font-face {font-family: MJXc-TeX-math-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size1-R; src: local('MathJax\_Size1'), local('MathJax\_Size1-Regular')}
@font-face {font-family: MJXc-TeX-size1-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size1-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size1-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size1-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size2-R; src: local('MathJax\_Size2'), local('MathJax\_Size2-Regular')}
@font-face {font-family: MJXc-TeX-size2-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size2-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size2-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size2-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size3-R; src: local('MathJax\_Size3'), local('MathJax\_Size3-Regular')}
@font-face {font-family: MJXc-TeX-size3-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size3-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size3-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size3-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size4-R; src: local('MathJax\_Size4'), local('MathJax\_Size4-Regular')}
@font-face {font-family: MJXc-TeX-size4-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size4-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size4-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size4-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-R; src: local('MathJax\_Vector'), local('MathJax\_Vector-Regular')}
@font-face {font-family: MJXc-TeX-vec-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-B; src: local('MathJax\_Vector Bold'), local('MathJax\_Vector-Bold')}
@font-face {font-family: MJXc-TeX-vec-Bx; src: local('MathJax\_Vector'); font-weight: bold}
@font-face {font-family: MJXc-TeX-vec-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Bold.otf') format('opentype')}
All three components are modeled as logistic curves — assuming that they are improving at some exponential constant rate but will saturate in the future (Cotra 2020).
Overall, I can strongly recommend reading through the report, as it is the most detailed work on AI timelines to my knowledge available. There is [a summary for the AI Alignment newsletter](https://www.alignmentforum.org/posts/cxQtz3RP4qsqTkEwL/an-121-forecasting-transformative-ai-timelines-using) and you can find the model in [this spreadsheet](https://docs.google.com/spreadsheets/d/1TjNQyVHvHlC-sZbcA7CRKcCp0NxV6MkkqBvL408xrJw/edit#gid=505210495)<span style="text-decoration:underline;">.</span>
Instead of discussing the whole piece, the following subsections will discuss some concepts on how to think about (1) compute prices and (2) compute spending. I will also present Cotra’s forecasts.
4.2 Forecasting Computing Prices
--------------------------------
Computing prices are informed by the purchase of computing hardware, energy costs, and potentially connected engineering time. As a useful proxy one can think about renting computational power from cloud services, such as Google Cloud or Amazon Web Services (AWS). The compute performance times the hourly renting rate brings access to a quantity of compute for a set price. This price would include all the costs, including a markup to be profitable.
**Figure 4.2**: Hardware prices as a component for forecasting effective compute.
As a proxy metric FLOP/$ is often used. We have two options to *advance* in this domain:
* **Better**: Our computing hardware achieves more FLOP/S (for the same price).
* **Cheaper**: Our computing hardware gets cheaper (while having the same amount of FLOP/S).
For thinking about those trends, I will be discussing Moore’s Law, chip architectures, and hardware paradigms. Those trends did and might lead to more FLOP per $.
### Moore's Law
A common way to model progress in computing hardware is Moore's law. It is probably the most well-known and also commonly used outside the research domain. It is mainly used to describe the exponential growth of technology — sometimes more precisely in the manner of *every two years the computing power doubles.*
Both are wrong but capture an interpretation that is becoming *less accurate*. The original Moore's law quotes:
>
> “Moore's law is the observation that the number of transistors in a dense integrated circuit (IC) doubles about every two years.”
>
>
>
**Figure 4.3**: (Original) Moore’s Law — the number of transistors on computing hardware over time. (Taken from [Our World in Data](https://ourworldindata.org/technological-progress#the-exponential-increase-of-the-number-of-transistors-on-integrated-circuits).)
Transistors are the fundamental building block of integrated circuits (IC) (or chips), so having more transistors in an IC is advantageous. However, in the end, for our forecast, we care about increased performance or reduced costs — and Moore’s Law does not describe this directly. It is a direct driver for efficiency (power use of each transistor) but not for performance. Having more building blocks available can build more memory, more processing cores, and others, and those can lead to speed improvements but not necessarily *need to*.
**Figure 4.4**: CPU improvements rates[[2]](#fn-eLo8wnA6BwgDXpJoz-2) normalized relative to 1979. (Taken from (Khan 2020).)
Figure 4.4 shows the normalized improvements of transistors per chip (blue), the efficiency (red), and the speed (green). The central insight is that the doubling rate of Moore’s law did a pretty good job describing the efficiency and speed improvements until 2005, but CPU speed could not maintain this trend.
**Figure 4.5**: The performance of CPUs (in SPECint, a standard CPU benchmark) over time depicting the different growth rates per year over the three eras: multiple chips in minicomputers, single microprocessors, and multi-core microprocessors. (Taken from (Shalf 2020b).)
The performance trend of CPUs could not be maintained over time and we see a decreasing yearly growth rate. This is partially explained by the end of eras as the previous trend could not be scaled (single microprocessor) and new directions were more complex and not a pure hardware job, such as multicore-architectures (Figure 4.5).
**Figure 4.6**: The performance over time of transistors, threads, clock frequency, power and number of cores. (The black dots and trend line depict the number of cores.) (Taken from (Shalf 2020b).)
Dissecting this trend into other components reveals some of the progress drivers and the start of new eras (Figure 4.6).
#### Moore’s Law Conclusion
Long story short, *Moore’s law end's* — you have heard this before. This is not my message here. Moore’s law was a useful proxy for the overall performance and progress of technology, and it still sometimes is (independent of its literal meaning). Despite that, Moore’s Law does not capture trends across computing paradigms or predominator architecture types (as seen in Figure 4.5 and 4.6) — it is useful *within an era*. For Moore’s law this era was the single microprocessor one.
In the previous section, we have discussed an exponential growth in the compute used for AI systems. However, we have just seen that actual performance growth is decreasing. Explaining the remaining AI compute growth with increased spending would be mistaken. Moore’s law does not capture chip architectures — such as the switch from CPUs to GPUs with AlexNet; and this is a predominant factor for growth in computing power, and consequently, compute. Therefore performance improvements can happen significantly faster than the pure improvement in transistor count and density would indicate.
To understand progress in computing hardware, especially within AI systems, the model of Moore’s law provides minimal information value. For describing a doubling of computing performance, we can simply tell it as a doubling of computing performance (or you can come up with your own law[[3]](#fn-eLo8wnA6BwgDXpJoz-3)). Dissecting any performance growth will always be complex (remember our three basic components: logic, memory and interconnect) but if we do so, we should focus on the most important contributors on higher abstraction layers[[4]](#fn-eLo8wnA6BwgDXpJoz-4).
### Chip Architectures: From Flexibility to Efficiency
In [Part 1 - Section 2.2](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#2_2_Compute_Trends__2012_to_2018), we have discussed that a new era, the modern era, was introduced by AlexNet leveraging a certain chip architecture[[5]](#fn-eLo8wnA6BwgDXpJoz-5): GPUs. Graphical processing units (GPUs) are a type of integrated circuit which were originally designed for computing graphics to then be displayed. Typical operations were rendering polygons and other geometric calculations — operations which are mathematically mapped as matrix multiplications. The partial results of the matrix multiplications can be computed independent from one another which allows a parallelized computation, and hence, the original design of a GPU: a chip architecture with highly parallelized computing units. Due to the highly parallel architecture of GPUs they are also well suited for non-graphical computations: for *[embarrassingly parallel](https://www.wikiwand.com/en/Embarrassingly_parallel)* problems, such as training neural nets.
**Figure 4.7**: The spectrum of chip architectures with trade-offs in regards to efficiency and flexibility. (Taken from (Microsoft Documentation 2020).)
GPUs are one example of such a chip architecture across a spectrum. While GPUs are somewhat specialized due to their parallelized architecture, they can still execute various workloads. This makes them more efficient than our general-purpose processors, CPUs, and less flexible regarding their workload (Figure 4.7).
Walking further on the spectrum towards less flexible (more specialized) but more efficient, we find architectures such as field-programmable gate arrays (FPGAs) and application-specific integrated circuits (ASICs). As the name of an ASICs implies, it is a dedicated hardware architecture for a specific application — making it specialized (and not flexible at all) but highly efficient at the dedicated task.
**Figure 4.8**: Complexity-flexibility trade-offs for different approaches for implementation in digital systems. (Taken from lecture slides of [Electronic Design Automation](https://www.ice.rwth-aachen.de/teaching/courses-in-summer-semester/electronic-design-automation/) class at RWTH Aachen.)
Thompson et al. discuss in “[The decline of computers as a general purpose technology](https://dl.acm.org/doi/10.1145/3430936)” the trend from general-purpose computing towards specialization. They differentiate modern systems between the *fast lane* and *slow lane.* While we can execute all kinds of applications and tasks on general-purpose processors, we can tailor ASICs to a specialized workload. For applications where it is economically feasible to create specialized processors, they are on the *fast lane*. There is enough demand, and the application’s workload is specific enough to benefit from dedicated hardware.
Other applications with diverse workloads and less demand have to rely on general-purpose processors and do not benefit from the efficient and accelerated ICs — this is the *slow lane* (Thompson and Spanuth 2021).
An example of an application being on the fast lane is Bitcoin mining. Bitcoin mining has relied for years now on ASICs due to the highly specific nature of the mining operation. It is economically not sustainable to mine without dedicated hardware, as those mining ASICs are orders of magnitude (OOM) more efficient.
#### Chip Architectures Conclusion
Moving from general-purpose processors to highly specialized ones if the economic incentives allow is a recent trend and useful model for classifying and thinking about progress. We have seen for applications that are *specific* enough and demand, such as Bitcoin mining, the industry moves towards specialized processors, and competing without is not feasible.
For AI systems, we have seen that moving from CPUs towards GPUs has enabled the field and resulted in a new compute growth trend. However, we have not seen “the ASICs” of AI systems yet. Clearly, the economic incentives align, as the AI market is big enough, and the trend is similar old as Bitcoin. One problem is the clearly defined application or workload. Whereas bitcoin mining simply executes the same block of operations that make up the function [SHA-1](https://www.wikiwand.com/en/SHA-1), for AI systems, this workload is not clearly defined — there is not *the one AI function*. However, we might see a convergence in the future towards certain basic building blocks and operations, where *more* specialized processors might be feasible. I will not discuss the details of this trend and the feasibility but would be interested in an investigation (see [Appendix A](#a-research-questions)). This is an important concept to monitor. I am not saying we will move further on the spectrum for the whole domain — we might not, as AI is too general. However, we might go for a specific AI system’s architecture, and if we do so, we can expect OOM of progress (Figure 4.9).
**Table 4.9**: Comparing state-of-the-Art AI chips to state-of-the-art CPUs. (Taken from (Khan 2020).)
We have seen trends moving further from the GPU towards the ASIC on the spectrum, e.g., [Google’s TPU](https://www.wikiwand.com/en/Tensor_Processing_Unit).
### Hardware Paradigms
Our dominant hardware paradigm is and was integrated circuits for the last 50 years — given that it is currently our most efficient one.
**Figure 4.10**: The performance over time is categorized in different hardware paradigms, such as mechanical, relay, vacuum tube, transistors, and most recently, integrated circuits. (Taken from (Cotra 2020) and [Wikimedia](https://commons.wikimedia.org/w/index.php?curid=55002144).)
Nonetheless, we explore alternative paradigms (in parallel) over time, and once they are more efficient (and cheaper) than the current dominant paradigm, the field as a whole will transition towards that paradigm, such as optical computing, quantum computing, or others. Consequently, one should continuously evaluate the new hardware paradigms on the horizon, estimate their computational gains, and feasibility within the next decade.
### Hardware in Cotra’s TAI Timeline Model
Cotra assumes a doubling time of 2.5 years and then leveling off after 6 OOM of progress for FLOP per $ by 2100. This is half as many OOM of progress we had over the last 60 years (1960s to 2020s).
Cotra’s goes into more detail in the [appendix](https://docs.google.com/document/d/1qjgBkoHO_kDuUYqy_Vws0fpf-dG5pTU4b8Uej6ff2Fg/edit#heading=h.nmcod2jynsy4). She acknowledges that this forecast is probably the least informed piece of her model[[6]](#fn-eLo8wnA6BwgDXpJoz-6). Nonetheless, there are various ideas which we can relate to our previous sections.
Here is the brief summary of how a ≈144-fold increase could be achieved in the next ≈20 years (the factors are multiplicative). We can get better by:
* Increasing transistors efficiency (traditional Moore’s Law)
+ Factor of ≈3
* Deep learning specific chip design choices (such as low precision computing, addressing the communication bottleneck (interconnect))
+ Factor of ≈6
And, we can get cheaper by the stabilization of chip design and enabling an economy of scale:
* Semiconductor industry amortize their R&D cost due to slower improvements
+ Factor of ≈2
* Sale price amortization when improvements are slower
+ Factor of ≈2
* A combination of economies of scale, greater specialization and more intense optimization (reducing the amortize cost of GPUs as compared to the power consumption cost)
+ Factor of ≈2
Overall, there will *either* be room for improvement in chip design, or chip design will *stabilize* which enables the above outlined improvements in the economy of scale (learning curves). Consequently, if you believe that technological progress (more performance for the same price) might halt, the compute costs will continue decreasing, as we then get *cheaper* (same performance for a decreased price).
4.3 Forecasting Compute Spending
--------------------------------
**Figure 4.11**: Compute spending as a component for the amount of effective compute available.
Once we know the price of compute, we need to estimate the potential spending. We will quickly discuss the estimate of Cotra’s model and the importance of dissecting progress into hardware improvements, increased spendings, and their economic limitations.
### Compute Spending in Cotra’s TAI Timeline Model
For hardware spending, we estimate the maximum amount (2020 $) an actor is willing to spend on the final training run. The current estimate for the most expensive run in a published paper was the final training run for AlphaStar at roughly $1M.
Cotra compares the maximum a single actor is willing to spend to a mega-project, such as the Manhattan Project or the Apollo Program, around 0.5% of the US GDP for four years. As AI will be more economically and strategically valuable, she estimates the spending with up to 1% of GDP of the largest country for up to 5 years (assuming GDP is growing at ≈3% per year).
### Economical limits
We have discussed before (in [Section 2.2](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#2_2_Compute_Trends__2012_to_2018)) that it is unclear how much of the increase in compute is due to more performant hardware or increased spending. If we assume that spending is capped at a certain percentage (e.g., at 1% of US GDP), those trends are not sustainable if increased spending is the dominant component.
Carey discusses this in “[Interpreting AI compute trends](https://aiimpacts.org/interpreting-ai-compute-trends/)” and breaks down the trend by dissecting it in FLOPS per $ and increased spending.[[7]](#fn-eLo8wnA6BwgDXpJoz-7) He extrapolates the trend of spending and estimates an end of the trend in 3.5 to 10 years (from 2018) — also assuming a Megaproject with 1% of US GDP spending (Carey 2018).
Thompson et al. also discuss this and conclude that the current trend is “economically, technically and environmentally unsustainable”, as the requirement for computation for the training is outperforming hardware performance (Figure 4.12) (Thompson et al. 2020).
**Figure 4.12**: Computing power demanded by deep learning. (Taken from (Thompson et al. 2020).)
4.4 Forecasting Algorithmic Progress
------------------------------------
**Figure 4.13**: Algorithmic progress as a component for the amount of effective compute available.
Forecasting algorithmic progress is out of scope for this piece. However, for the sake of completeness, I list it here. It is significant for the *effective* amount of compute available. As previously discussed, the best piece available is “[AI and Efficiency](https://openai.com/blog/ai-and-efficiency/)”. For ImageNet, the algorithmic improvements halve the compute required for the same task every 16 months (Hernandez and Brown 2020).
More research in algorithmic efficiency is crucial for estimating effective compute available and the current public research in this domain is limited.
### Algorithmic Progress in Cotra’s TAI Timeline Model
Cotra estimates the algorithmic progress with a halving time of 2 to 3 years with a maximum of 1 to 5 OOM.
4.5 Conclusion
--------------
We have discussed the role of compute for Transformative AI timelines and dissected the relevant components. For improving forecasting efforts breaking it down into conceptual blocks is useful. We have focused on three concepts for compute prices: Moore’s law, chip architectures, and hardware paradigms, which provide valuable insights for thinking about progress and, consequently, forecasting it. This piece does not outline a concrete strategy for forecasting *compute*. Rather, it lists various ideas and discusses them related to Cotra’s TAI timeline.
Considering the economy of scale is an important model which might allow cheaper hardware even though our technical and hardware progress might be reduced to a smaller extent and longer innovation cycles. Additionally, the switch in hardware paradigms is essential to monitor. The [Appendix A](https://www.lesswrong.com/posts/G4KHuYC3pHry6yMhi/compute-research-questions-and-metrics-transformative-ai-and#A__Research_Questions) lists some research questions related to this.
Overall, I think the compute concept of Cotra’s TAI timeline model is impressive work and an excellent method to estimate effective compute available at year *Y* (I cannot comment on the other parts of the model). Improving the hardware estimates is a possible and potential part of my future work. In the next section, I will outline some concrete proposals which might allow us to come up with better compute price estimates.
5 Better Compute Forecasts
==========================
Highlights
* Researchers should share insights into their AI system’s training by disclosing the amount of compute used and its connected details.
1. Ideally, we should make it a requirement for publications and reduce the technical burden of recording the used compute.
* For forecasting hardware progress, we can rely on conceptual models and categories of innovation. We can break this down into:
1. Progress in current computing paradigms
2. Economy of scale for existing technologies
3. Introduction of new computing paradigms
4. Unknown unknowns
* We should also monitor the dominant design strategy of hardware as this informs our forecasts. The three design strategies are (1) hardware-driven algorithm design, (2) algorithm-driven hardware design, and (3) co-develop hardware and algorithm.
* Metrics, such as FLOPS/$, often give limited insights, as they only represent one of the three computer components (memory, interconnect, and logic). Understanding their limitations is essential for forecasting.
---
We have discussed how to forecast future compute progress. However, these forecasting efforts could easily be more informed. In this section, I will sketch some proposals which could improve forecasting efforts.
As discussed, Ajeya Cotra also thinks that the compute part could be easily improved and she “would be very excited” for people to take up the open questions around hardware progress and more in-depth analyses, and I agree.[[8]](#fn-eLo8wnA6BwgDXpJoz-8) Also Holden Karnofsky would be interested in better compute forecasts.[[9]](#fn-eLo8wnA6BwgDXpJoz-9)
This section presents some of my and others' thoughts on the topic, but they could easily be improved with better data, as well as efforts to improve our collective mental models and technical understanding of AI hardware. In this section, I offer some specific suggestions for how to improve our understanding of this area. The listed proposals are in no particular order.
5.1 Share AI System Training Insights
-------------------------------------
I would like to ask AI researchers to publish data on their compute usage. Ideally, researchers should publish the following metrics, for the final training run, and, preferably, also for the development stages:
* Amount of compute used in FLOPs/OPs.
* The number representation used (float16, float32, bfloat16, int8, etc.)
* The computing system and hardware used: type of GPUs, number of GPUs, and the networking of the system.
+ Ideally a metric for the utilization of the system.
* The software and optimization stack (compilers etc) used.
* The rough amount of money spent on the compute.
This is, of course, easier said than done. I do think that most researchers are not aware of the information value of those data points for the field of macro ML research.[[10]](#fn-eLo8wnA6BwgDXpJoz-10) Also, accessing data, such as compute used, is not easily accessible and often *hidden behind layers of complexity* for ML researchers. Therefore, it would be highly valuable to develop a plugin that allows researchers to access the used compute, the same way as they access validation loss or other key metrics. One could also imagine making the publication of those metrics required for the publication at top conferences — similar to the societal impact statement for NeurIPS (Centre for the Governance of AI 2020).
5.2 Components of Hardware Progress
-----------------------------------
When forecasting the compute prices or the price per FLOP, it is desirable to understand the categories *where progress might happen*. We can break this down into:
* Additional progress in current computing paradigms
* Economy of scale in the current dominant computing paradigm
* Introduction of new computing paradigms
And, of course, we always have *unknown unknowns*.
**Additional progress in current computing paradigms** describes the continued improvement in the digital computing domain using transistors on semiconductors. This itself is a broad category and the category where we have seen the progress of the last 50 years. Examples are architectural innovations (from CPU to ASICs), smaller transistors, post-CMOS, other semiconductor material innovations, high-performance computation communication, and many more.
**Economy of scale in the current dominant computing paradigm** describes the reduced costs when innovation periods are extended and amortization happens (as discussed in [Section 4.2](#Hardware_in_Cotra_s_TAI_Timeline_Model)). The recent innovation cycles are relatively short, which leads to higher prices. Once innovation stalls, we could enter a period of amortization which enables an economy of scale which drives price further down. At this point, the energy costs could also become the dominant cost factor of compute (Cotra 2020).
**The introduction of new computing paradigms** characterizes a new upcoming computing paradigm that is not yet economically feasible but might in the future be more efficient than the currently dominant one. Examples are quantum computing, optical computing, neuromorphic computing, and others.
And just to be safe, **unknown unknowns**.
### Design Strategies
Those innovations within hardware progress components are then enabled by different design strategies. The design strategy describes *how* we innovate. I think this is also a helpful model to classify progress and model for hardware innovation. Shalf outlines three different design strategies (Shalf 2020a):
* Hardware-drive algorithm design
* Algorithm-driven hardware design
* Co-develop hardware and algorithm
**Hardware-driven algorithm design** describes the modification of algorithms to take advantage of existing and new accelerators. Examples are the usage of GPUs where we adapt our training algorithms for deployment on GPUs.
**Algorithm-driven hardware design** is hardware specifically designed for specific workloads with dedicated accelerators based on the application and its algorithms. However, the development costs are way higher. As discussed before, this is the *fast lane* and only available when the market demand (and application) allows it.
**Co-develop hardware and algorithms** describes more of an economic model of interacting with the semiconductor industry. The previous general-purpose computing has led to a handoff relationship. However, various innovations have led to multiple companies co-designing their hardware with software within the last few years. Examples in the AI systems are various chips for smartphones and Google TPUs, or Tesla’s recent AI chip announcement: [Dojo](https://www.wikiwand.com/en/Tesla_Dojo). This design strategy seems to have become a trend for actors which can afford so.
**Figure 5.1**: Components and models for conceptualizing hardware progress.
5.3 Conclusion
--------------
All in all, forecasting compute is a major undertaking, and this piece does not outline a concrete strategy on how to go about it; instead, it lists various ideas. I see it as a start for potentially building a bigger conceptual model and providing estimates and forecasts on the subcategories. I would recommend doing the same for hardware spending.
For a discussion on common metrics, see [Appendix B](https://www.lesswrong.com/posts/G4KHuYC3pHry6yMhi/compute-research-questions-and-metrics-transformative-ai-and#B__Metrics).
Next Post: Compute Governance and Conclusions
=============================================
The next post "[*Compute Governance and Conclusions [3/4]*](https://www.lesswrong.com/posts/M3xpp7CZ2JaSafDJB/computer-governance-and-conclusions-transformative-ai-and)" will attempt to:
6. Briefly outline the relevance of compute for AI Governance ([Part 3 - Section 6](https://www.lesswrong.com/posts/M3xpp7CZ2JaSafDJB/computer-governance-and-conclusions-transformative-ai-and#6__Compute_Governance)).
7. Conclude this report and discuss next steps ([Part 3 - Section 7](https://www.lesswrong.com/posts/M3xpp7CZ2JaSafDJB/computer-governance-and-conclusions-transformative-ai-and#7__Conclusions)).
Acknowledgments
===============
You can find the acknowledgments in the [summary](https://www.lesswrong.com/posts/XJYdnHQqpengWn3xb/transformative-ai-and-compute-summary-2).
References
==========
The references are listed in the [summary](https://www.lesswrong.com/posts/XJYdnHQqpengWn3xb/transformative-ai-and-compute-summary-2).
---
1. We have discussed under and overutilization in [Part 1 - Section 1](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#1__Compute). Compute hardware is usually underutilized due to the processor-memory performance gap. [↩︎](#fnref-eLo8wnA6BwgDXpJoz-1)
2. For transistor data, see Max Roser and Hannah Ritchie, “Technological Progress,” Our World in Data, 2019, <https://ourworldindata.org/technological-progress>. For efficiency data, see Koomey et al., “Energy Efficiency of Computing." For speed data, see Hennessy et al., “New Golden Age,” 54. [↩︎](#fnref-eLo8wnA6BwgDXpJoz-2)
3. For example there's [Huang's Law](https://www.wikiwand.com/en/Huang%27s_law): “*Huang's Law is an observation in computer science and engineering that advancements inGPUs are growing at a rate much faster than with traditionalCPUs.*” [↩︎](#fnref-eLo8wnA6BwgDXpJoz-3)
4. With higher abstraction layers I refer to the abstraction layers of computing systems. From electrons in a semiconductor to software. Higher abstraction layers are usually easier to translate into performance growth, whereas an innovation in transistors is hard to *translate over all the layers *into a performance increase*.* [↩︎](#fnref-eLo8wnA6BwgDXpJoz-4)
5. The word *architecture* is used for describing various hardware concepts on different layers. In this piece with chip architecture, I refer to the spectrum from CPU to ASICs — while all of them still rely on digital computing and semiconductor material. [↩︎](#fnref-eLo8wnA6BwgDXpJoz-5)
6. “*Because they have not been the primary focus of my research, I consider these estimates unusually unstable, and expect that talking to a hardware expert could easily change my mind.*” [↩︎](#fnref-eLo8wnA6BwgDXpJoz-6)
7. By using the dataset “[2017 trend in the cost of computing](https://aiimpacts.org/recent-trend-in-the-cost-of-computing/)” by AI Impacts. While I agree with the overall premise that spending will be capped and has been a major driver, I am skeptical of using the AI Impacts dataset for estimating cost of computing trends. I will be discussing some caveats on commonly used metrics in [Appendix B](#heading=h.gr8f7a47tpw8). [↩︎](#fnref-eLo8wnA6BwgDXpJoz-7)
8. [AXRP Episode 7.5](https://www.alignmentforum.org/posts/CuDYhLLXq6FuHvGZc/axrp-episode-7-5-forecasting-transformative-ai-from) (released in May 2021; only the transcript is available):
>
> “[...] but I would be very excited for a piece that was just like, here is where hardware progress will tap out and here’s when I think that will happen and why.”
>
>
>
>
> “I think an easier in-road is trying to answer one of the many open questions in the timelines report. Trying to really nail hardware forecasting, or really nail algorithmic progress some way. And I think that if it’s good is adding direct value and it’s also getting you noticed.”
>
>
>
[↩︎](#fnref-eLo8wnA6BwgDXpJoz-8)
9. [80’000hours episode #109](https://80000hours.org/podcast/episodes/holden-karnofsky-most-important-century/#investigations-holden-would-love-to-do-015548) (released in August 2021):
>
> “A thing that would really change my mind a lot is if we did the better compute projections — I’m expecting that to come out to similar conclusions to what we have at the moment; different, but similar — but maybe we did them and it was just like [...]“
>
>
>
[↩︎](#fnref-eLo8wnA6BwgDXpJoz-9)
10. While I agree that our estimates (as discussed in [Part 1 - Section 2.3](https://www.lesswrong.com/posts/uYXAv6Audr2y4ytJe/what-is-compute-transformative-ai-and-compute-1-4#2_3_Compute_Trends__An_Update_8_)) might be *good enough* for trends over multiple years (assuming that our error is within one OOM), having access to the exact numbers is beneficial because:
1. It makes the data acquisition process easier and faster.
2. The current estimates use different methods depending on the published data (based on GPU days and assuming utilization, based on the model size/number of parameters, or based on the inference compute cost).
3. There is more than “just the final training run”. Other processes of the development might play a role (or at least should be explored): fine-tuning the hyper-parameters, neural architecture search, and others.
4. We do not have any insights in the breakup into increased spending or better hardware.[↩︎](#fnref-eLo8wnA6BwgDXpJoz-10) |
8efbbbe4-9e0b-4e5b-8a6a-acf90a281659 | trentmkelly/LessWrong-43k | LessWrong | Reasons for Excitement about Impact of Impact Measure Research
Can we get impact measurement right? Does there exist One Equation To Rule Them All?
I think there’s a decent chance there isn’t a simple airtight way to implement AUP which lines up with AUPconceptual, mostly because it’s just incredibly difficult in general to perfectly specify the reward function.
Reasons why it might be feasible: we’re trying to get the agent to do the goal without it becoming more able to do the goal, which is conceptually simple and natural; since we’ve been able to handle previous problems with AUP with clever design choice modifications, it’s plausible we can do the same for all future problems; since there are a lot of ways to measure power due to instrumental convergence, that increases the chance at least one of them will work; intuitively, this sounds like the kind of thing which could work (if you told me “you can build superintelligent agents which don’t try to seek power by penalizing them for becoming more able to achieve their own goal”, I wouldn’t exactly die of shock).
Even so, I am (perhaps surprisingly) not that excited about actually using impact measures to restrain advanced AI systems. Let’s review some concerns I provided in Reasons for Pessimism about Impact of Impact Measures:
* Competitive and social pressures incentivize people to cut corners on safety measures, especially those which add overhead. Especially so for training time, assuming the designers slowly increase aggressiveness until they get a reasonable policy.
* In a world where we know how to build powerful AI but not how to align it (which is actually probably the scenario in which impact measures do the most work), we play a very unfavorable game while we use low-impact agents to somehow transition to a stable, good future: the first person to set the aggressiveness too high, or to discard the impact measure entirely, ends the game.
* In a What Failure Looks Like-esque scenario, it isn't clear how impact-limiting any single agent helps prevent the worl |
489c603a-e241-45e3-b75e-907808e8b6c2 | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | Conditioning Predictive Models: The case for competitiveness
*This is the third of seven posts in the [Conditioning Predictive Models Sequence](https://www.alignmentforum.org/s/n3utvGrgC2SGi9xQX) based on the paper “[Conditioning Predictive Models: Risks and Strategies](https://arxiv.org/abs/2302.00805)” by Evan Hubinger, Adam Jermyn, Johannes Treutlein, Rubi Hudson, and Kate Woolverton. Each post in the sequence corresponds to a different section of the paper.*
3. The case for competitiveness
===============================
In addition to ensuring that we can condition predictive models safely, for such an approach to work as a way to actually reduce AI existential risk, we also need it to be the case that it is competitive—that is, that it doesn’t impose too much of an [alignment tax](https://forum.effectivealtruism.org/posts/63stBTw3WAW6k45dY/paul-christiano-current-work-in-ai-alignment). Following “[How do we become confident in the safety of a machine learning system?](https://www.alignmentforum.org/posts/FDJnZt8Ks2djouQTZ/how-do-we-become-confident-in-the-safety-of-a-machine)” we’ll distinguish between two different aspects of competitiveness here that we’ll need to address:
>
> **Training rationale competitiveness [(Implementation competitiveness)]:** how hard the training rationale [(getting the model we want)] is to execute. That is, a proposal should fail on training rationale competitiveness if its training rationale is significantly more difficult to implement—e.g. because of compute or data requirements—than competing alternatives.
>
>
> **Training goal competitiveness [(Performance competitiveness)]:** whether, if successfully achieved, the training goal [(the model we want)] would be powerful enough to compete with other AI systems. That is, a proposal should fail on training goal competitiveness if it would be easily outcompeted by other AI systems that might exist in the world.
>
>
>
To make these concepts easier to keep track of absent the full [training stories ontology](https://www.alignmentforum.org/posts/FDJnZt8Ks2djouQTZ/how-do-we-become-confident-in-the-safety-of-a-machine), we’ll call training rationale competitiveness *implementation competitiveness*, since it describes the difficulty of implementing the proposal, and training goal competitiveness *performance competitiveness*, since it describes the achievable performance for the resulting model.
Implementation competitiveness
------------------------------
The most generally capable models today, large language models, seem to be well-described as predictive models. That may change, but we think it is also at least quite plausible that the first human-level AGI will be some sort of predictive model, likely similar in structure to current LLMs.
Furthermore, LLM pre-training in particular seems to be where most of the capabilities of the most advanced current models come from: the vast majority of compute spent training large language models is spent in pre-training, not fine-tuning. Additionally, our guess is that the fine-tuning that is done is best modeled as targeting existing capabilities rather than introducing entirely new capabilities.
Assuming that, after pre-training, LLMs are well-understood as predictive models, that suggests two possibilities for how to think about different fine-tuning regimes:
1. The fine-tuning resulted in a particular conditional of the original pre-trained predictive model.
2. The fine-tuning targeted the capabilities by turning the predictive model into one that is no longer well-understood as predictive.
In the first case, the conditioning predictive models approach would simply be a variation on the exact techniques currently used at the forefront of capabilities, making it hopefully implementation competitive by default.[[1]](#fn-TewAjxeJHWJGCkCob-1) The main way we think such an implementation competitiveness argument could fail is if the fine-tuning necessary to get the sort of conditionals we describe here is substantially harder than alternative fine-tuning paradigms.
In particular, we think it is likely the case that our proposed solutions will add some amount of overhead to the implementation and use of predictive models, since they involve being substantially more careful regarding what conditionals are used.[[2]](#fn-TewAjxeJHWJGCkCob-2) That being said, we’re hopeful that the overhead requirement here should not be too extreme: the conditionals we propose are not fundamentally different than those already in use, and in many cases the conditionals we want—e.g. predict a human researcher—might actually be more straightforward than some of the sorts of conditionals that current RLHF approaches often aim for—e.g. [behave as a helpful, harmless, and honest agent](https://arxiv.org/abs/2204.05862).
In the second case, however, the conditioning predictive models approach would require us to either halt or at least substantially change fine-tuning practices—which could certainly hamper the implementation competitiveness of this approach. Thus, it’s worth carefully investigating and understanding when different fine-tuning regimes are likely to fall into which of these categories—especially because, if in fact some fine-tuning results in a model that’s no longer well-understood as a predictive model, none of the ways of ensuring such a model’s safety that we discuss here would still apply.
Currently, the state of the art in language modeling uses reinforcement learning from human feedback (RLHF) as the fine-tuning approach of choice for targeting LLM capabilities, and thus will be the method that we focus on exploring. To the extent that RLHF is just a [way to access a wider array of conditionals](https://www.alignmentforum.org/posts/chevXfQmRYrTZnj8r/conditioning-prompts-and-fine-tuning), this seems fine and can be incorporated into our approach. Currently, however, we don’t understand under what circumstances RLHF can be thought of as conditioning a model versus doing something more complicated. We will go into the specific question of how to think about how our approach interacts with RLHF in more detail in [Section 4](https://www.alignmentforum.org/posts/qoHwKgLFfPcEuwaba/conditioning-predictive-models-making-inner-alignment-as).
Furthermore, we note that there has been [some work](https://arxiv.org/pdf/2206.15474.pdf) on using LLMs to predict world events. Performance of GPT-2-style models is decidedly worse than aggregations of expert humans, but this work serves as a proof of concept that the kind of approach we envision is possible at all.
Beyond fine-tuning, another potential implementation competitiveness issue lies in transparency and interpretability. Later we will discuss using transparency and interpretability to address potential inner alignment issues with training a predictive model—we recognize that this could create an implementation competitiveness burden. However, we do not believe that inner alignment issues that might require transparency and interpretability tools to mitigate are at all specific to this approach. The inner alignment issues that might arise are fully general, and apply to all approaches using LLMs. Thus, any other safe approach using LLMs will also need to use the same transparency and interpretability tooling to mitigate inner alignment issues, meaning that this approach is no less implementation competitive than any other safe approach.
That being said, our hope is that transparency tools are not necessary for inner alignment, and that predictive models have a decent chance of being inner aligned by default. Furthermore, we think that the inner alignment issues for predictive models are potentially substantially easier than those for agents. We will discuss these issues further in [Section 4](https://www.alignmentforum.org/posts/qoHwKgLFfPcEuwaba/conditioning-predictive-models-making-inner-alignment-as).
Performance competitiveness
---------------------------
In order to ensure performance competitiveness, we have to ensure that our approach is able to accomplish all of the tasks that would otherwise be able to be accomplished via other means of training and deploying powerful AI systems. However, if we operate under the assumption that LLMs are likely to be the first powerful AI systems, then all we need to do is ensure that anything anyone else can do with an LLM we can do via careful conditioning as well: that is, we need to ensure that we aren’t imposing any restrictions on what one can do with an LLM that affect capabilities too much.
Our hope is that our techniques are general enough to be able to safely target an LLM at any task. We of course require that the capability in fact be present in the LLM to begin with such that it could possibly be elicited, but beyond that our hope is that almost any capability that an LLM has can be safely elicited via the sorts of conditioning approaches that we discuss.
### Restricting ourselves to only predicting humans
Unfortunately, we absolutely are restricting what things we are allowing one to do with an LLM. In particular, we are restricting ourselves to only predicting (augmented) humans rather than other AI systems.
We think that this is the primary way that the overall performance competitiveness argument goes wrong: we are limited to tasks theoretically performable by some conceivable human or group of humans, since we are explicitly avoiding simulating AIs. As a result, the basic approach described here is not an indefinitely scalable alignment solution, in the sense that its ability to produce aligned models stops working at some high level of model capabilities.
That being said, we think this limitation is not necessarily fatal for our overall approach: it seems very plausible that we could target LLM capabilities up to the level of any task that any group of highly-capable people could accomplish under perfect conditions over some reasonable period of time, say e.g. five years—what we described previously as the “max human” level. Though not arbitrarily powerful, our hope is that the capabilities in the first transformative LLMs that are available to be elicited will be below that level—and that we will be able to then use those capabilities to help us align the next set of models that are above that level.
Thus, even though we can’t safely elicit capabilities just via conditioning beyond the threshold of what any humans could theoretically accomplish, as long as the capabilities that we need to successfully navigate the transition from slightly superhuman/transformative LLMs to highly superhuman AGIs is under that threshold, that fact shouldn’t constitute a fatal performance competitiveness issue.
### Restricting ourselves to dialogue agents that claim to be humans
In addition to the capability limitations of predicting humans described above, there is another potential limitation to just doing human prediction: it makes it substantially harder to train AI systems that truthfully represent what they are. In particular, if you ask a predictive model predicting a helpful human assistant whether it’s an AI or a human, it will claim to be a human, which is correct in the sense that claiming to be a human is what a human would do, but incorrect in the sense that the AI system is not itself a human.
Truthfully identifying as an AI is important for helpful AI assistants. Impersonating a human would present a potentially thorny deployment and societal issue, since it could be quite confusing for users to interact with AIs that claim to be humans. A ban on impersonating humans, if this is not clearly recognizable to the user, has also been suggested as part of the [proposed EU AI Act](https://artificialintelligenceact.eu/the-act/). Given that creating AI assistants and chatbots is an increasingly important use of predictive models, it would be an important gap if one could not build safe AI assistants just by predicting humans.
That being said, there are multiple ways to potentially address this sort of limitation. One idea could be to simply predict humans pretending to be AIs—though this does increase the possibility of those humans knowing they’re being predicted, as we discussed [previously](https://www.alignmentforum.org/posts/3kkmXfvCv9DmT3kwx/conditioning-predictive-models-outer-alignment-via-careful#Humans_discover_they_re_being_simulated). Alternatively, another approach could be to use two models, one of which generates the original output that it predicts a human would produce, and another that performs the task of translating that output into the equivalent thing but claiming to be an AI rather than a human—both of which are tasks that humans should be plenty capable of, and thus should be doable just via predicting humans. These patches could backfire, however, since the conditional needed to implement a capable assistant may be strange and unlikely and could thus elicit unsafe AI predictions, though we are hopeful one could develop a safe version of such patches.[[3]](#fn-TewAjxeJHWJGCkCob-3)
### Restricting ourselves to only using predictive models
In addition to only predicting humans, another major restriction of the conditioning predictive models approach is that we use predictive models at all—approaches that instead attempt to e.g. turn an LLM into an agent are clearly ruled out. Thus, we need conditioning predictive models to be performance competitive with such alternative agentic proposals.
Certainly, we will not be able to get performance parity between human predictors and agents in regimes with arbitrary levels of capabilities, due the basic limitations around predicting humans that we just discussed. However, we are optimistic that performance parity up to that point is achievable.
The most basic argument for why agents might be more performance competitive than predictors is that they can make plans and strategies for how to achieve particular goals over the long-term. In the regime where we are only dealing with capabilities below the max human level, however, we can simply get such planning from predicting humans.
However, there is one specific case where human agentic planning might not be sufficient, even in the sub-max-human capability regime: agents might be better than predictors at planning and strategizing with their own *internal cognitive resources* such as time, attention, etc. Just saying we are going to predict humans is not sufficient to deal with this criticism: if a predictor attempting to predict humans isn’t managing its own internal resources as effectively as an alternative more agentic model, then it’ll have worse performance in practice even though in theory the humans it was predicting would have been able to accomplish the task.
In our opinion, however, we think this sort of problem is far from fatal. To start with, just because a model is attempting to solve a prediction task doesn’t mean it’s incapable of using more agentic planning/optimization machinery to manage its own internal cognitive resources. In fact, we think doing so is probably necessary for all practical competent predictors: if my goal is to predict what will show up on the Alignment Forum tomorrow, I can’t just model the entire world with no internal prioritization—I have to be judicious and careful in modeling only the aspects of it that are directly relevant. Though this does ensure that our predictor will be a [mesa-optimizer](https://www.alignmentforum.org/s/r9tYkB2a8Fp4DN8yB) in some capacity, we think inner aligning such a mesa-optimizer is potentially achievable, as we will discuss in [Section 4](https://www.alignmentforum.org/posts/qoHwKgLFfPcEuwaba/conditioning-predictive-models-making-inner-alignment-as).[[4]](#fn-TewAjxeJHWJGCkCob-4)
There is an additional issue here, however, that comes from the prediction loss: doing well on per-token log loss requires modeling a lot of random fiddly details—e.g. what synonyms/formatting/grammar/etc. people will use—that aren’t very important to the sort of performance—e.g. actually accomplishing complex tasks—that we care about. As a result, prediction models might end up devoting a bunch of extra capacity to modeling these sorts of fiddly details in a way that makes them less competitive.
In our opinion, however, this sort of issue is quite addressable. First, it’s worth pointing out that it’s unlikely to be a very large difference in competitiveness: the fiddly details are not as hard to predict as the more complex large-scale phenomena, so as performance gains from fiddly detail prediction get eaten up, relatively more and more capacity should start going to high-level modeling instead. Second, if the model is capable of dynamically allocating its capacity based on what is most relevant to focus on for each conditional, then a lot of this problem can be solved just via selecting the right conditional. In particular, if you use a conditional that makes it very clear what the allowable formatting is, what the sort of voice that is being used is, etc., then predicting things like synonyms and formatting becomes much easier, and the model can devote more relative capacity to predicting more high-level phenomena.
### Handling sequential reasoning
Even if the only mechanism ever used for eliciting LLM capabilities is some form of conditioning, performance competitiveness for careful conditioning approaches is not guaranteed, since we are placing restrictions on the sorts of conditionals we’re allowing ourselves to use.
In particular, we have to deal with situations where the only competitive way of eliciting a certain capability is via sequential reasoning—e.g. via chain of thought reasoning,“[think step by step](https://twitter.com/arankomatsuzaki/status/1529278580189908993)” prompts, etc. In our opinion, we think it is highly likely that such sequential reasoning approaches will be necessary to use any predictive model in a competitive way, and thus ensuring that careful conditioning approaches are compatible with such sequential reasoning is quite important.
Under the model that LLMs are well-understood as predictive models, sequential reasoning effectively does two things:
1. it helps convince the model that it should be predicting a good reasoner rather than a poor one, and
2. it effectively splits up the overall prediction task into individual, easier prediction tasks, thus giving the model more overall compute to work with.
Notably, neither of these benefits are incompatible with also conditioning the model in such a way so as to, for example, ensure that the reasoner it’s predicting is a human rather than an AI. In fact, doing so seems necessary to make these sorts of sequential reasoning techniques safe: without them, conditioning on a good reasoner just increases the probability that the model will predict a malign AI as AIs become better reasoners than humans, absent some technique to prevent it from doing so.
That being said, there is a valid concern that requiring such sequential reasoning to be done by predicting humans is uncompetitive. Certainly, requiring sequential reasoning to be done by predicting humans will be uncompetitive for eliciting any capabilities beyond the max human level. However, in regimes where no such capabilities are present to be elicited, we are optimistic that purely relying on sub-max-human sequential reasoning should be sufficient.
Unfortunately, there is one major performance competitiveness roadblock here, which is very related to the previous concern regarding managing internal cognitive resources. While we think that a predictive model should be able to efficiently handle managing its own internal cognitive resources, sequential reasoning approaches effectively give it additional *external* cognitive resources to manage as well, specifically how to use its chain of thought scratchpad. For example, a chain of thought model has to figure out how to decompose questions in such a way that the subproblems are easier for it—the model—to solve than the original question.
Ideally, the goal would be to predict how some human or group of humans would manage those external cognitive resources. There is one major issue with just using human resource management, however, which is that the optimal way of managing external cognitive resources might be very different between humans and AIs—e.g. due to differences in what sorts of subtasks each is relatively better or worse at. As a result, managing external cognitive resources the way that a human would could be substantially worse because it limits the model’s ability to steer the sequential reasoning into subtasks that the model is best at and away from subtasks that the model is worst at.
There are some potential solutions to this problem, though we think it is overall a serious problem. First, there are a lot of possible counterfactual humans that we can draw on here—and humans themselves also vary a great degree regarding what sorts of tasks they’re best at. As a result, we could try to simply condition on predicting a human or group of humans with similar strengths and weaknesses to the model. Unfortunately, this does come with the downside of potentially increasing the model’s credence that the so-called “human” it’s trying to predict is actually an AI. Second, we could try to give the predicted human the explicit task of trying to break down the problem in such a way that plays to the strengths and weaknesses of the AI. Unfortunately, though this doesn’t come with the problem of increasing the model’s credence that the human it is predicting is an AI, it should certainly increase the model’s credence that there are AIs in the world of the human it is predicting, which—as we discussed [previously](https://www.alignmentforum.org/posts/3kkmXfvCv9DmT3kwx/conditioning-predictive-models-outer-alignment-via-careful#2c__Major_challenge__Predicting_other_AI_systems)—could be similarly problematic, though potentially less bad.
---
1. If a new paradigm displaced LLM pretraining + fine-tuning, though, then all bets are off. [↩︎](#fnref-TewAjxeJHWJGCkCob-1)
2. For example, it is likely to be strictly more difficult to implement an LLM that never predicts other AIs than one that does, as well as strictly more cumbersome to have to restrict an LLM to only ever be interacted with using carefully crafted, safe conditionals. [↩︎](#fnref-TewAjxeJHWJGCkCob-2)
3. Another potentially tricky issue with any of these approaches of training a predictive model to claim to be a human is that if it’s actually not well-described as a predictive model—and is instead e.g. well-described as an agent—then we would actively be training it to lie in telling us that it’s a human rather than an AI, which could result in a substantially less aligned agent than we would have gotten otherwise. Furthermore, such patches could also lead to an assistant that is more fragile and susceptible to jailbreaking due to the limitation of having to go through predicting some human. [↩︎](#fnref-TewAjxeJHWJGCkCob-3)
4. Notably, this does also open us up to some additional inner alignment concerns related to doing the internal cognitive resource management in the right way, which we discuss [later](https://www.alignmentforum.org/posts/qoHwKgLFfPcEuwaba/conditioning-predictive-models-making-inner-alignment-as#Dealing_with_internal_cognitive_resource_management). [↩︎](#fnref-TewAjxeJHWJGCkCob-4) |
614ba2ca-1107-4cda-a74d-e13a46c8e58f | trentmkelly/LessWrong-43k | LessWrong | Locating and Editing Knowledge in LMs
In my previous post I went over some common approaches for updating LMs with fresh knowledge. Here, I detail a specific approach that has gained popularity in recent years - locating and editing factual associations in language models. I do not believe in this approach, in this post I try to summarize it fairly, and explain why I don’t quite like it.
Do LMs Store Facts in Their Weights?
Language models that employ the transformer architecture have Feed Forward Networks (FFNs) as an important subcomponent. For any specific layer, the FFN has 2 sublayers within it.
During the forward pass of a LM, the FFN takes as input a dense vector representation from the previous layer and outputs a dense vector of its own.
Two key operations happen here, at each sublayer the vector is multiplied into a matrix of weights. There is a line of thought that sees the weights of the FFNs as a sort of neural database that stores memories.
Let us call the dense vector that goes into the FFN the query vector, the first layer weights the key matrix and the second layer weights the value matrix. Now look at how the FFN works, it takes in the query, applies a key transformation to it and gets a key representation and then finally uses the key representation to recall parts of the value matrix to provide a value representation (the final output). This gives us the interpretation:
The FFN component is said to store memories that are accessible via specific inputs to the component. The keys store input patterns that commonly occur in the training data, and the values store outputs that are triggered by those input patterns.
The paper that discovered this collected the sentences most associated with particular keys and had humans categorize them. The sentences that activated keys in the early layers showed shallow linguistic patterns (e.g. the word substitute is the final token), while those that triggered later layers have semantic patterns (e.g. whether the text refers to a TV show). In |
77405de2-4141-4c06-861d-eed9d38f6fa9 | trentmkelly/LessWrong-43k | LessWrong | [Old] Wayfinding series
As I said in the intro to the "mapmaking series" post, I'm reposting some content from my old blog that people found useful. They particularly found things I wrote in this series useful, and of the two series I agree that this is likely the more useful one, the former being reposted mainly because this one occasionally references it. If you are familiar with LW much you probably don't need to read the first post.
As I also said in the first post, this is old content that I no longer entirely endorse, although I think most of it remains useful and surprisingly skillful advice given how little I knew back then. I've been about 7 different people between when I wrote these posts and now, to give you some idea of the distance I'm suggesting I have from it. Nonetheless, I think learning to master the topics I discuss here is pretty essential if you want to attain to at least whatever level of mastery I've achieved at being a human, much else besides not included.
I hope these words treat you well.
----------------------------------------
finding your way
having now a good sense of maps and mapmaking, we can begin to use our maps to find our way through the territory. this requires more than the skill of map reading, which is implicit to mapmaking. you need the skill of the wayfinding: finding your way through the territory to a destination.
what sort of destination? the kinds of destinations that exist in the territory: possible future worlds states you could find yourself in. for example, hungry? find your way to eating a sandwich. thirsty? find your way to drinking a glass of water. ennui? find you way to having a life's purpose. to put it in a story:
> you are trying to go to your friend's house. you have a map that shows you that to get there you need to walk down the street, though a patch of brush, past an angry dog, and then up a narrow lane with your friend's house at the end. the map tells you where to go, but just reading that map is not enough to get yo |
b5a126cf-9dad-47be-8b60-ed3fd7109564 | StampyAI/alignment-research-dataset/eaforum | Effective Altruism Forum | Credo AI is hiring!
Credo AI is hiring technical folks versed in responsible AI; if you are interested, please apply! If you aren’t a data scientist or other technical professional, but are inspired by our mission, please reach out. We are always looking for talented, passionate folks.
### **What is Credo AI?**
[Credo AI](https://www.credo.ai/company) is a ventured-backed Responsible AI (RAI) company focused on the assessment and governance of AI systems. Our goal is to move RAI development from an “ethical” choice to an obvious one. We aim to do this both by making it easier for organizations to integrate RAI practices into their AI development and by collaborating with policy makers to set up appropriate ecosystem incentives. The ultimate goal is to reduce the risk of deploying AI systems, allowing us to capture the AI's benefits while mitigating its costs.
We make RAI easier with our [governance, risk & compliance](https://en.wikipedia.org/wiki/Governance,_risk_management,_and_compliance) (GRC) product and an open-source AI assessment framework called [Lens](https://credoai-lens.readthedocs.io/en/latest/). Our data science team focuses on the latter with the goal of creating the most approachable tool for comprehensive RAI assessment for any AI system. We take a “what you can’t observe, you can’t control” approach to this space, and believe that assessment lays the foundation for all other aspects of a RAI ecosystem (e.g., auditing, mitigation, regulation). Here's a [notebook](https://credoai-lens.readthedocs.io/en/latest/notebooks/quickstart.html) showing some of Len's capabilities in code.
A particular focus of our governance product is involving diverse stakeholders in the governance of AI systems. Technical teams obviously have important perspectives, but so do compliance, governance, product, [social scientists](https://distill.pub/2019/safety-needs-social-scientists/), etc. We aim to provide the forum for their effective collaboration in our GRC software, and provide technical outputs via Lens that are useful for everyone.
Our collaboration with policy organizations is just beginning, but we are already contributing our perspective to the broader policy conversation. For instance, see our comments to [NIST on Artificial Intelligence Risks](https://www.credo.ai/blog/credo-ai-comments-on-nists-artificial-intelligence-risk-management-framework). Our CEO and technical policy advisors have been part of the World Economic Forum, The Center for AI & Digital Policy, the Mozilla Foundation and the Biden Administration.
### **Who is Credo AI?**
We are a small, ambitious team committed to RAI. We are a global, remote company with expertise in building amazing products, technical policy, social science, and, of course, AI. We are a humble group, and are focused on learning from the policy community, academia, and, most critically, our customers. Find a bit more about us and our founder [here](https://www.forbes.com/sites/brucerogers/2022/02/09/navrina-singh-founds-credo-ai-to-align-ai-with-human-values/?sh=5b0193397192).
The data science team is currently 2 people ([Ian Eisenberg](https://www.linkedin.com/in/ian-eisenberg-aa17b594/) and [Amin Rasekh](https://www.linkedin.com/in/aminrasekh/)). The needs in this space are immense, so early hires will have the opportunity (and indeed the responsibility!) for owning significant components of our assessment framework.
### **Relationship to Effective Altruism**
The EA community has argued that AI governance is an important cause area for a while. A great starter can be found [here](https://forum.effectivealtruism.org/posts/42reWndoTEhFqu6T8/ai-governance-opportunity-and-theory-of-impact), many other posts are found [here](https://forum.effectivealtruism.org/tag/governance-of-artificial-intelligence). The majority of work is either being pursued by particular governments, academia, or a few non-profits.
However, making principles of AI governance a reality requires a broader ecosystem approach, consisting of governments enacting regulations, customers and businesses demanding AI accountability from AI service providers, academic institutions exploring evidentially-backed governance approaches, independent auditors focused on evaluating AI systems, and more. There are many interacting parts that must come together to change the development of the AI systems affecting our lives - most of which are developed in the corporate sector.
Credo AI specifically engages with the corporate sector, and plays a role that is sometimes described as [Model Ops](https://en.wikipedia.org/wiki/ModelOps). We are the bridge between theory, policy and implementation that can connect with corporate decision making. We think of ourselves as creating a responsible “choice architecture” that promotes responsible practices. For better or worse the bar for RAI development is very low right now, which means there is a ton we can do to improve the status quo, whether that’s by making relatively well researched approaches to “fair AI” easy to incorporate into model development, making existing regulations more understandable, or being the first to practically operationalize bleeding-edge RAI approaches.
There is plenty of low hanging fruit for us at these early stages, but our ambitions are great. In the medium term we would like to build the most comprehensive assessment framework for AI systems and help all AI-focused companies improve their RAI processes. At the longer time scale, we would love to inform an empirical theory of AI policy. [Others](https://arxiv.org/abs/2001.00078) have pointed out the difficulty AI policies will have in keeping up with the speed of technical innovation. Building a better science of effective AI governance requires knowledge of the policies corporations are employing, and their relative effectiveness. We are far (far!) away from having this kind of detail, but it’s the kind of long-term ambition we have.
### **Who should apply?**
If you believe you have the skills and passion for contributing to the nascent world of AI governance, we want to hear from you!
To help you figure out if that’s you, I’ll describe some of the near-term challenges we are facing:
* How can general principles of Responsible AI be operationalized?
* How can we programmatically assess AI systems for principles like fairness, transparency, etc?
* How can we make those assessments understandable and actionable for a broad range of stakeholders?
The data science team’s broader goal is to build an assessment framework that connects AI teams with RAI tools developed in academia, the open source world, and at Credo AI. We want this framework to make employing best practices easy so that “responsible AI development” becomes an obvious choice for any developer. Creating this assessment framework lays the groundwork for Credo AI’s other missions, which is generally to ensure that AI is developed responsibly.
To be a bit more concrete we are looking for people who:
* Have an existing passion and knowledge in this space. You don’t have to have previously worked in “AI safety” or “responsible AI”, but this post shouldn’t be the first time you are thinking about these issues!
* For the data science team you need to know how to program in python, and familiarity with the process of AI development is a definite plus.
* If you *aren’t* interested in the data science team, but believe you can contribute, please reach out anyway!
* Have an “owner” mindset. This word gets tossed around a lot, but at a startup our size it truly is a requirement. The ground is fertile and we need people who have the vision and follow through to develop wonderful things.
### **Hiring process and details**
Our hiring process starts with you reaching out. We are looking for anyone who read the above section and thinks “that’s me!”. If that’s you, send a message to me at [ian@credo.ai](mailto:ian@credo.ai). Please include “Effective Altruism Forum” in the subject line so I know where you heard of us.
Specific jobs and requirements are posted [here](https://www.credo.ai/jobs).
**Q&A**
We welcome any questions about what working at Credo AI is like, more details about our product, the hiring process, what we're looking for, or whether you should apply. You can reach out to [jobs@credo.ai](mailto:jobs@credo.ai), or reach out directly to me at [ian@credo.ai](mailto:ian@credo.ai).
### **Who am I?**
My name is [Ian Eisenberg](https://www.linkedin.com/in/ian-eisenberg-aa17b594/). I’m a cognitive neuroscientist who moved into machine learning after finishing my PhD. While working in ML, I quickly realized that I was more interested in the socio-technical challenges of responsible AI development than AI capabilities, first becoming inspired by the challenges of building aligned AI systems. I am an organizer of [Effective Altruism San Francisco](https://www.facebook.com/effectivealtruismsf), and spend some of my volunteer time with the pro-bono data science organization [DataKind](https://www.datakind.org/). |
0076f264-9722-4058-ac50-424fbdde1d8c | trentmkelly/LessWrong-43k | LessWrong | Skepticism About DeepMind's "Grandmaster-Level" Chess Without Search
Update: Authors commented below that their unpublished results show that actually the bot is as good as described; many thanks to them.
The paper
First, addressing misconceptions that could come from the title or from the paper's framing as relevant to LLM scaling:
1. The model didn't learn from observing many move traces from high-level games. Instead, they trained a 270M-parameter model to map (board state,legal move) pairs to Stockfish 16's predicted win probability after playing the move. This can be described as imitating the play of an oracle that reflects Stockfish's ability at 50 milliseconds per move. Then they evaluated a system that made the model's highest-value move for a given position.
2. The system resulted in some quirks that required workarounds during play.
1. The board states were encoded in FEN notation, which doesn't provide information about which previous board states have occurred; this is relevant in a small number of situations because players can claim an immediate draw when a board state is repeated three times.
2. The model is a classifier, so it doesn't actually predict Stockfish win-probability but instead predicts the bin (out of 128) into which that probability falls. So in a very dominant position (e.g. king and rook versus a lone king) the model doesn't distinguish between moves that lead to mate and can alternate between winning lines without ever achieving checkmate. Some of these draws-from-winning-positions were averted by letting Stockfish finish the game if the top five moves according to both the model and Stockfish had a win probability above 99%.
Some comments have been critical on these grounds, like Yoav Goldberg's "Grand-master Level Chess without Search: Modeling Choices and their Implications" (h/t Max Nadeau). But these don't seem that severe to me. Representing the input as a sequence of board states rather than the final board state would have also been a weird choice, since in fact the specific mov |
e2bb5492-e719-4e91-b311-c06cb9f28c80 | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | [AN #80]: Why AI risk might be solved without additional intervention from longtermists
Find all Alignment Newsletter resources [here](http://rohinshah.com/alignment-newsletter/). In particular, you can [sign up](http://eepurl.com/dqMSZj), or look through this [spreadsheet](https://docs.google.com/spreadsheets/d/1PwWbWZ6FPqAgZWOoOcXM8N_tUCuxpEyMbN1NYYC02aM/edit?usp=sharing) of all summaries that have ever been in the newsletter. I'm always happy to hear feedback; you can send it to me by replying to this email.
Audio version [here](http://alignment-newsletter.libsyn.com/alignment-newsletter-80) (may not be up yet).
Welcome to another special edition of the newsletter! In this edition, I summarize four conversations that AI Impacts had with researchers who were optimistic that AI safety would be solved "by default". (Note that one of the conversations was with me.)
While all four of these conversations covered very different topics, I think there were three main points of convergence. First, we were relatively **unconvinced by the traditional arguments for AI risk**, and **find discontinuities relatively unlikely**. Second, we were more optimistic about **solving the problem in the future**, when we know more about the problem and have more evidence about powerful AI systems. And finally, we were more optimistic that as we get more evidence of the problem in the future, **the existing ML community will actually try to fix that problem**.
[Conversation with Paul Christiano](https://aiimpacts.org/conversation-with-paul-christiano/) *(Paul Christiano, Asya Bergal, Ronny Fernandez, and Robert Long)* (summarized by Rohin): There can't be too many things that reduce the expected value of the future by 10%; if there were, there would be no expected value left (ETA: see [this comment](https://www.lesswrong.com/posts/QknPz9JQTQpGdaWDp/an-80-why-ai-risk-might-be-solved-without-additional#WWufqvbyESxNDEtDJ)). So, the prior that any particular thing has such an impact should be quite low. With AI in particular, obviously we're going to try to make AI systems that do what we want them to do. So starting from this position of optimism, we can then evaluate the arguments for doom. The two main arguments: first, we can't distinguish ahead of time between AIs that are trying to do the right thing, and AIs that are trying to kill us, because the latter will behave nicely until they can execute a treacherous turn. Second, since we don't have a crisp concept of "doing the right thing", we can't select AI systems on whether they are doing the right thing.
However, there are many "saving throws", or ways that the argument could break down, avoiding doom. Perhaps there's no problem at all, or perhaps we can cope with it with a little bit of effort, or perhaps we can coordinate to not build AIs that destroy value. Paul assigns a decent amount of probability to each of these (and other) saving throws, and any one of them suffices to avoid doom. This leads Paul to estimate that AI risk reduces the expected value of the future by roughly 10%, a relatively optimistic number. Since it is so neglected, concerted effort by longtermists could reduce it to 5%, making it still a very valuable area for impact. The main way he expects to change his mind is from evidence from more powerful AI systems, e.g. as we build more powerful AI systems, perhaps inner optimizer concerns will materialize and we'll see examples where an AI system executes a non-catastrophic treacherous turn.
Paul also believes that clean algorithmic problems are usually solvable in 10 years, or provably impossible, and early failures to solve a problem don't provide much evidence of the difficulty of the problem (unless they generate proofs of impossibility). So, the fact that we don't know how to solve alignment now doesn't provide very strong evidence that the problem is impossible. Even if the clean versions of the problem were impossible, that would suggest that the problem is much more messy, which requires more concerted effort to solve but also tends to be just a long list of relatively easy tasks to do. (In contrast, MIRI thinks that prosaic AGI alignment is probably impossible.)
Note that even finding out that the problem is impossible can help; it makes it more likely that we can all coordinate to not build dangerous AI systems, since no one *wants* to build an unaligned AI system. Paul thinks that right now the case for AI risk is not very compelling, and so people don't care much about it, but if we could generate more compelling arguments, then they would take it more seriously. If instead you think that the case is already compelling (as MIRI does), then you would be correspondingly more pessimistic about others taking the arguments seriously and coordinating to avoid building unaligned AI.
One potential reason MIRI is more doomy is that they take a somewhat broader view of AI safety: in particular, in addition to building an AI that is trying to do what you want it to do, they would also like to ensure that when the AI builds successors, it does so well. In contrast, Paul simply wants to leave the next generation of AI systems in at least as good a situation as we find ourselves in now, since they will be both better informed and more intelligent than we are. MIRI has also previously defined aligned AI as one that produces good outcomes when run, which is a much broader conception of the problem than Paul has. But probably the main disagreement between MIRI and ML researchers and that ML researchers expect that we'll try a bunch of stuff, and something will work out, whereas MIRI expects that the problem is really hard, such that trial and error will only get you solutions that *appear* to work.
**Rohin's opinion:** A general theme here seems to be that MIRI feels like they have very strong arguments, while Paul thinks that they're plausible arguments, but aren't extremely strong evidence. Simply having a lot more uncertainty leads Paul to be much more optimistic. I agree with most of this.
However, I do disagree with the point about "clean" problems. I agree that clean algorithmic problems are usually solved within 10 years or are provably impossible, but it doesn't seem to me like AI risk counts as a clean algorithmic problem: we don't have a nice formal statement of the problem that doesn't rely on intuitive concepts like "optimization", "trying to do something", etc. This suggests to me that AI risk is more "messy", and so may require more time to solve.
[Conversation with Rohin Shah](https://aiimpacts.org/conversation-with-rohin-shah/) *(Rohin Shah, Asya Bergal, Robert Long, and Sara Haxhia)* (summarized by Rohin): The main reason I am optimistic about AI safety is that we will see problems in advance, and we will solve them, because nobody wants to build unaligned AI. A likely crux is that I think that the ML community will actually solve the problems, as opposed to applying a bandaid fix that doesn't scale. I don't know why there are different underlying intuitions here.
In addition, many of the classic arguments for AI safety involve a system that can be decomposed into an objective function and a world model, which I suspect will not be a good way to model future AI systems. In particular, current systems trained by RL look like a grab bag of heuristics that correlate well with obtaining high reward. I think that as AI systems become more powerful, the heuristics will become more and more general, but they still won't decompose naturally into an objective function, a world model, and search. In addition, we can look at humans as an example: we don't fully pursue convergent instrumental subgoals; for example, humans can be convinced to pursue different goals. This makes me more skeptical of traditional arguments.
I would guess that AI systems will become *more* interpretable in the future, as they start using the features / concepts / abstractions that humans are using. Eventually, sufficiently intelligent AI systems will probably find even better concepts that are alien to us, but if we only consider AI systems that are (say) 10x more intelligent than us, they will probably still be using human-understandable concepts. This should make alignment and oversight of these systems significantly easier. For significantly stronger systems, we should be delegating the problem to the AI systems that are 10x more intelligent than us. (This is very similar to the picture painted in [Chris Olah’s views on AGI safety](https://www.alignmentforum.org/posts/X2i9dQQK3gETCyqh2/chris-olah-s-views-on-agi-safety) ([AN #72](https://mailchi.mp/cac125522aa3/an-72-alignment-robustness-methodology-and-system-building-as-research-priorities-for-ai-safety)), but that had not been published and I was not aware of Chris's views at the time of this conversation.)
I'm also less worried about race dynamics increasing *accident* risk than the median researcher. The benefit of racing a little bit faster is to have a little bit more power / control over the future, while also increasing the risk of extinction a little bit. This seems like a bad trade from each agent's perspective. (That is, the Nash equilibrium is for all agents to be cautious, because the potential upside of racing is small and the potential downside is large.) I'd be more worried if [AI risk is real AND not everyone agrees AI risk is real when we have powerful AI systems], or if the potential upside was larger (e.g. if racing a little more made it much more likely that you could achieve a decisive strategic advantage).
Overall, it feels like there's around 90% chance that AI would not cause x-risk without additional intervention by longtermists. The biggest disagreement between me and more pessimistic researchers is that I think gradual takeoff is much more likely than discontinuous takeoff (and in fact, the first, third and fourth paragraphs above are quite weak if there's a discontinuous takeoff). If I condition on discontinuous takeoff, then I mostly get very confused about what the world looks like, but I also get a lot more worried about AI risk, especially because the "AI is to humans as humans are to ants" analogy starts looking more accurate. In the interview I said 70% chance of doom in this world, but with *way* more uncertainty than any of the other credences, because I'm really confused about what that world looks like. Two other disagreements, besides the ones above: I don't buy [Realism about rationality](https://www.lesswrong.com/posts/suxvE2ddnYMPJN9HD/realism-about-rationality) ([AN #25](https://mailchi.mp/0c5eeec28f75/alignment-newsletter-25)), whereas I expect many pessimistic researchers do. I may also be more pessimistic about our ability to write proofs about fuzzy concepts like those that arise in alignment.
On timelines, I estimated a very rough 50% chance of AGI within 20 years, and 30-40% chance that it would be using "essentially current techniques" (which is obnoxiously hard to define). Conditional on both of those, I estimated 70% chance that it would be something like a mesa optimizer; mostly because optimization is a very useful instrumental strategy for solving many tasks, especially because gradient descent and other current algorithms are very weak optimization algorithms (relative to e.g. humans), and so learned optimization algorithms will be necessary to reach human levels of sample efficiency.
**Rohin's opinion:** Looking over this again, I'm realizing that I didn't emphasize enough that most of my optimism comes from the more outside view type considerations: that we'll get warning signs that the ML community won't ignore, and that the AI risk arguments are not watertight. The other parts are particular inside view disagreements that make me more optimistic, but they don't factor in much into my optimism besides being examples of how the meta considerations could play out. I'd recommend [this comment of mine](https://www.lesswrong.com/posts/mdau2DBSMi5bWXPGA/useful-does-not-mean-secure#xccsZeboCNcNJeGas) to get more of a sense of how the meta considerations factor into my thinking.
I was also glad to see that I still broadly agree with things I said ~5 months ago (since no major new opposing evidence has come up since then), though as I mentioned above, I would now change what I place emphasis on.
[Conversation with Robin Hanson](https://aiimpacts.org/conversation-with-robin-hanson/) *(Robin Hanson, Asya Bergal, and Robert Long)* (summarized by Rohin): The main theme of this conversation is that AI safety does not look particularly compelling on an outside view. Progress in most areas is relatively incremental and continuous; we should expect the same to be true for AI, suggesting that timelines should be quite long, on the order of centuries. The current AI boom looks similar to previous AI booms, which didn't amount to much in the past.
Timelines could be short if progress in AI were "lumpy", as in a FOOM scenario. This could happen if intelligence was one simple thing that just has to be discovered, but Robin expects that intelligence is actually a bunch of not-very-general tools that together let us do many things, and we simply have to find all of these tools, which will presumably not be lumpy. Most of the value from tools comes from more specific, narrow tools, and intelligence should be similar. In addition, the literature on human uniqueness suggests that it wasn't "raw intelligence" or small changes to brain architecture that makes humans unique, it's our ability to process culture (communicating via language, learning from others, etc).
In any case, many researchers are now distancing themselves from the FOOM scenario, and are instead arguing that AI risk occurs due to standard principal-agency problems, in the situation where the agent (AI) is much smarter than the principal (human). Robin thinks that this doesn't agree with the existing literature on principal-agent problems, in which losses from principal-agent problems tend to be bounded, even when the agent is smarter than the principal.
You might think that since the stakes are so high, it's worth working on it anyway. Robin agrees that it's worth having a few people (say a hundred) pay attention to the problem, but doesn't think it's worth spending a lot of effort on it right now. Effort is much more effective and useful once the problem becomes clear, or once you are working with a concrete design; we have neither of these right now and so we should expect that most effort ends up being ineffective. It would be better if we saved our resources for the future, or if we spent time thinking about other ways that the future could go (as in his book, Age of Em).
It's especially bad that AI safety has thousands of "fans", because this leads to a "crying wolf" effect -- even if the researchers have subtle, nuanced beliefs, they cannot control the message that the fans convey, which will not be nuanced and will instead confidently predict doom. Then when doom doesn't happen, people will learn not to believe arguments about AI risk.
**Rohin's opinion:** Interestingly, I agree with almost all of this, even though it's (kind of) arguing that I shouldn't be doing AI safety research at all. The main place I disagree is that losses from principal-agent problems with perfectly rational agents are bounded -- this seems crazy to me, and I'd be interested in specific paper recommendations (though note [I](https://www.lesswrong.com/posts/ktDKfKqukTPRiuEPM/robin-hanson-on-the-futurist-focus-on-ai#fecYAwjmMSZ9KRfPL) [and](https://www.lesswrong.com/posts/ktDKfKqukTPRiuEPM/robin-hanson-on-the-futurist-focus-on-ai#yRLaEzT57K4q5Qz5H) [others](https://www.lesswrong.com/posts/ktDKfKqukTPRiuEPM/robin-hanson-on-the-futurist-focus-on-ai#p6CGEFbqaYJb49jME) have searched and not found many).
On the point about lumpiness, my model is that there are only a few underlying factors (such as the ability to process culture) that allow humans to so quickly learn to do so many tasks, and almost all tasks require near-human levels of these factors to be done well. So, once AI capabilities on these factors reach approximately human level, we will "suddenly" start to see AIs beating humans on many tasks, resulting in a "lumpy" increase on the metric of "number of tasks on which AI is superhuman" (which seems to be the metric that people often use, though I don't like it, precisely because it seems like it wouldn't measure progress well until AI becomes near-human-level).
[Conversation with Adam Gleave](https://aiimpacts.org/conversation-with-adam-gleave/) *(Adam Gleave et al)* (summarized by Rohin): Adam finds the traditional arguments for AI risk unconvincing. First, it isn't clear that we will build an AI system that is so capable that it can fight all of humanity from its initial position where it doesn't have any resources, legal protections, etc. While discontinuous progress in AI could cause this, Adam doesn't see much reason to expect such discontinuous progress: it seems like AI is progressing by using more computation rather than finding fundamental insights. Second, we don't know how difficult AI safety will turn out to be; he gives a probability of ~10% that the problem is as hard as (a caricature of) MIRI suggests, where any design not based on mathematical principles will be unsafe. This is especially true because as we get closer to AGI we'll have many more powerful AI techniques that we can leverage for safety. Thirdly, Adam does expect that AI researchers will eventually solve safety problems; they don't right now because it seems premature to work on those problems. Adam would be more worried if there were more arms race dynamics, or more empirical evidence or solid theoretical arguments in support of speculative concerns like inner optimizers. He would be less worried if AI researchers spontaneously started to work on relative problems (more than they already do).
Adam makes the case for AI safety work differently. At the highest level, it seems possible to build AGI, and some organizations are trying very hard to build AGI, and if they succeed it would be transformative. That alone is enough to justify some effort into making sure such a technology is used well. Then, looking at the field itself, it seems like the field is not currently focused on doing good science and engineering to build safe, reliable systems. So there is an opportunity to have an impact by pushing on safety and reliability. Finally, there are several technical problems that we do need to solve before AGI, such as how we get information about what humans actually want.
Adam also thinks that it's 40-50% likely that when we build AGI, a PhD thesis describing it would be understandable by researchers today without too much work, but ~50% that it's something radically different. However, it's only 10-20% likely that AGI comes only from small variations of current techniques (i.e. by vastly increasing data and compute). He would see this as more likely if we hit additional milestones by investing more compute and data (OpenAI Five was an example of such a milestone).
**Rohin's opinion:** I broadly agree with all of this, with two main differences. First, I am less worried about some of the technical problems that Adam mentions, such as how to get information about what humans want, or how to improve the robustness of AI systems, and more concerned about the more traditional problem of how to create an AI system that is *trying* to do what you want. Second, I am more bullish on the creation of AGI using small variations on current techniques, but vastly increasing compute and data (I'd assign ~30%, while Adam assigns 10-20%). |
cf11eee8-10a5-4ea5-8a63-ac85020d3d0d | trentmkelly/LessWrong-43k | LessWrong | Meetup : Dallas - Fort Worth Less Wrong Meetup 5/13/12
Discussion article for the meetup : Dallas - Fort Worth Less Wrong Meetup 5/13/12
WHEN: 13 May 2012 01:00:00PM (-0500)
WHERE: America's Best Coffee, Arlington
Hello Dallas-Fort Worth LessWrongians! If you live in the area, and you haven't come out to meet us yet, you are missing out!
We currently have regular meetups every Sunday at America's Best Coffee in Arlington at 1 PM until 3 PM. We have gotten a good handful of people to show up to these events so far, and it has been very enjoyable and productive.
The current goal, or mission statement, of this group can be summarized as follows: "We want to first understand rationality, and then learn how to apply rationality to our daily lives. During our meet-ups we wish to take advantage of having a community over what can only be accomplished alone."
We look forward to you coming out and meeting the rest of the group. Message me to ask to join our google group: https://groups.google.com/forum/#!forum/dfw-lesswrong-meetup
Discussion article for the meetup : Dallas - Fort Worth Less Wrong Meetup 5/13/12 |
1a3fa078-9526-49c9-b1de-60352325d160 | trentmkelly/LessWrong-43k | LessWrong | Longevity Insurance
Let's say we (as a country) ban life insurance and health insurance as separate packages [1] and require them to be combined in something I'll call "Longevity Insurance". The idea is that as a person/consumer, you can buy a "life expectancy" of 75 years, or 90 years, or whatever. In addition, you specify a maximum dollar amount that the longevity insurance will ever pay out--say, $2 million. If you have any medical issues throughout your life, up to the life expectancy threshold, the insurance plan will pay for your expenses. If it fails to keep you consciously alive for the duration of your "life expectancy", then upon your death, the policy guarantees that the company will pay the full remaining amount to your next of kin.
As an example, suppose you (let's say you're a woman) had purchased a 75-year policy, but you had a car accident. The paramedics tried to save you, and the hospital bill came to $100k, but even after that noble effort, you still died. As a result, your husband and children get $1.9M. Alternatively, if in our hypothetical situation they succeed in resuscitating you, the company would keep the $1.9M for future medical bills, and, if they fulfill their promise of life expectancy, they pocket the remainder as profit on your 75th birthday.
It seems like this arrangement would put all of the right incentives [2] in place for both companies and individuals. Most individuals would want to avoid trivial medical expenses in order to maximize payout to family in case of accidental death. Companies would want to maximize health and longevity in order to profit from the end-of-life payout. And our society would have a way to rationally consider the value of life without resorting to arguments that essentially conclude "life is of infinite value," and in doing so, prevent sensible gerontological triage. To put it into perspective, it makes little sense that we spend $1M (as a society) trying to save a 92-year-old when that same amount could have saved 10 t |
6fcdffa8-c2db-46ce-b7b7-80a8cc1b99d6 | trentmkelly/LessWrong-43k | LessWrong | Death and Desperation
I am worried about some of the tonal shifts around the future of AI, as it may relate to more vulnerable members of the community. While I understand Mr. Eudowski’s stance of “Death with Dignity,” I worry that it’s creating a dangerous feeling of desperation for some.
People make bad decisions when they feel threatened and without options. Violence starts to look more appealing, because there is a point where violence is warranted, even if it isn’t something most of us would consider.
One of the big take-always from this community is “do something:” you can make a difference if you’re willing to put in the work. How many have we seem who have taken up AI safety research? This is generally a good thing.
Once people think that they and their families are threatened, “do something” becomes a war cry. After all, bombing OpenAI datacenter might not have a high probability of succeeding, but when you feel like you’re out of options, it might seem to be your only hope.
This becomes more dangerous when you’re talking about people who feel disaffected, and struggle with anxiety and depression. Those who feel alone and desperate. This that don’t feel like they have a lot to lose, and maybe dream about becoming humanity’s savior.
I don’t know what to do about this, but I do think that it’s an important conversation. What can we do to minimize the chance of someone from our community committing violent acts? How do we fight this aspect of Moloch? |
c29b4bc4-6992-48a8-841f-c5791af607d3 | trentmkelly/LessWrong-43k | LessWrong | Operationalizing timelines
If you're forecasting AI progress or asking someone about their timelines, what event should you focus on?
tl;dr it's messy and I don't have answers.
AGI, TAI, etc. are bad. Mostly because they are vague or don't capture what we care about.
* AGI = artificial general intelligence (no canonical operationalization)
* This is vague/imprecise, and is used vague/imprecisely
* We care about capability-level; we don't directly care about generality
* Maybe we should be paying attention to specific AI capabilities, AI impacts, or conditions for AI catastrophe
* TAI = transformative AI, originally defined as "AI that precipitates a transition comparable to (or more significant than) the agricultural or industrial revolution" (see also discussion here)
* "a transition comparable to . . . the agricultural or industrial revolution" is vague, and I don't know what it looks like
* "precipitates" is ambiguous. Suppose for illustration that AI in 2025 would take 10 years to cause a transition comparable to the industrial revolution (if there was no more AI progress, or no more AI progress by humans), but AI in 2026 would take 1 year. Then the transition is precipitated by the 2026-AI, but the 2025-AI was capable enough to precipitate a transition. Is the 2025-AI TAI? If so, "TAI" seems to miss what we care about. And regardless, whether a set of AI systems precipitates a transition comparable to the industrial revolution is determined not just by the capabilities and other properties of the systems, but also by other facts about the world, which is weird. Also note that some forecasters believe that current Al would be "eventually transformative" but future Al will be transformative faster, so under some definitions, they believe we already have TAI.
* This is often used vaguely/imprecisely
* HLAI = human-level AI (no canonical operationalization)
* This is kinda vague/imprecise but can be operationalized pretty well, I think
* This may come after the |
bd4662d1-ec71-4fcc-a89a-094ff8f72ff7 | trentmkelly/LessWrong-43k | LessWrong | What are concepts for, and how to deal with alien concepts
|
eb118bd3-9b55-4c10-8aaa-c1660d4e6353 | trentmkelly/LessWrong-43k | LessWrong | Differential Progress and a Personal Commitment
Regarding the problem of differential progress in AI capability research vs AI Alignment research.
I intend to work in Artificial Intelligence, but I would want to pursue capability research over alignment research, and due to the nature of incentives in the two fields so would most people. This means that safety research would lag behind capability research which is a lose lose situation for everyone as expecting the people who first develop Human Level Machine Intelligence (HLMI) to hold off on deployment until safety research catches up is optimistic at best and outright naive at worst.
To do my own part in mitigating this problem, I've decided to commit to donate 10% of my income towards AI Safety, and if I decide to work full time in Safety I would reduce this to 5%, whereas if I instead choose to pursue capability research I would increase this to 20% (modulo acceptable standard of living and quality of life). This incentivises me to contribute to Safety research (or at least not worsen the problem), and if I do end up exacerbating the problem, I'll pay for it accordingly.
This is my own personal solution, and I make no claim that others should do something similar (even though I would prefer that they do). I'm currently personally poor (I don't work and have an allowance of around $50+ a month (PayPal didn't let me donate cents, or at least I didn't see how to), but I'm dependent on my parents so I have an acceptable standard of living and quality of life). It is more important to me that I donate at all to AI Safety research, than that I donate to the most effective AI Safety research organisation, and to prevent myself from procastinating under the guise of finding the most effective organisation, I just decided to donate to MIRI. Making this commitment public is so that I'm less likely to weasel out of it, so I should be creating these posts around once a month, and if 60 days go by without me creating a post about my donation towards AI Safety, feel fr |
48ee3b4f-550c-42dd-8e55-1c2ffac10742 | StampyAI/alignment-research-dataset/arbital | Arbital | Church-Turing thesis: Evidence for the Church-Turing thesis
As the Church-Turing thesis is not a [proper mathematical sentence](https://arbital.com/p/) we cannot prove it. However, we can collect [https://arbital.com/p/-3s](https://arbital.com/p/-3s) to increase our confidence in its correctness.
#The inductive argument
Every computational model we have seen so far is [reducible](https://arbital.com/p/) to Turing's model.
Indeed, the thesis was originally formulated independently by Church and Turing in reference to two different computational models ([https://arbital.com/p/Turing_machines](https://arbital.com/p/Turing_machines) and [https://arbital.com/p/Lambda_Calculus](https://arbital.com/p/Lambda_Calculus) respectively). When they were shown to be [equivalent](https://arbital.com/p/equivilance_relation) it was massive evidence in favor of both of them.
A non-exhaustive list of models which can be shown to be reducible to Turing machines are:
* [https://arbital.com/p/Lambda_calculus](https://arbital.com/p/Lambda_calculus)
* [https://arbital.com/p/Quantum_computation](https://arbital.com/p/Quantum_computation)
* [Non-deterministic_Turing_machines](https://arbital.com/p/Nondeterministic_Turing_machines)
* [https://arbital.com/p/Register_machines](https://arbital.com/p/Register_machines)
* The set of [https://arbital.com/p/-recursive_functions](https://arbital.com/p/-recursive_functions)
#Lack of counterexamples
Perhaps the strongest argument we have for the CT thesis is that there is not a widely accepted candidate to a counterexample of the thesis. This is unlike the [https://arbital.com/p/-4ct](https://arbital.com/p/-4ct), where quantum computation stands as a likely counterexample.
One may wonder whether the computational models which use a source of [randomness](https://arbital.com/p/) (such as quantum computation or [https://arbital.com/p/-probabilistic_Turing_machines](https://arbital.com/p/-probabilistic_Turing_machines)) are a proper counterexample to the thesis: after all, Turing machines are fully [https://arbital.com/p/-deterministic](https://arbital.com/p/-deterministic), so they cannot simulate randomness.
To properly explain this issue we have to recall what it means for a quantum computer or a probabilistic Turing machine to compute something: we say that such a device computes a function $f$ if for every input $x$ the probability of the device outputting $f(x)$ is greater or equal to some arbitrary constant greater than $1/2$. Thus we can compute $f$ in a classical machine, for there exists always the possibility of simulating every possible outcome of the randomness to deterministically compute the probability distribution of the output, and output as a result the possible outcome with greater probability.
Thus, randomness is reducible to Turing machines, and the CT thesis holds. |
50ad28d7-e7ea-42e2-86cc-627a65fdd882 | trentmkelly/LessWrong-43k | LessWrong | A Fresh FAQ on GiveWiki and Impact Markets Generally
Summary: This is an FAQ on the AI Safety GiveWiki at ai.givewiki.org. It’s open to anyone, and we’re particularly trying to attract s/x-risk projects at the moment! Some of the questions, though, apply to impact markets more generally. This document will give you an overview of what it is that we’re building and where we’re hoping to go with it.
But before we jump into the FAQ, a quick announcement:
We are looking for new projects and expressions of interest from donors!
1. If you’re a donor who doesn’t want to spend a lot of time researching your donations, you’ll be able to follow sophisticated donors who have skin in the game. Our impact market doubles as a crowdsourced charity evaluator for all the small, speculative, potentially-spectacular projects across all cause areas. You’ll be able to tap into the wisdom of our top donors to boost the impact of your donations. Please indicate your interest!
2. If you’re a donor who has insider knowledge of some space of nonprofit work or likes to thoroughly research your donations, you can use the platform to signal-boost the best projects. You get a “donor score” based on your track record of impact, and the higher your score, the greater your boost to the project. This lets you leverage your expertise for follow-on donations, getting the project funded faster. Please indicate your interest!
3. Are you fundraising for some project, as individual or organization? Please post it to our platform. No requirements when it comes to the format or scope, so you can copy-paste or link whatever proposals you already have. We want to make it easier for lesser-known projects to find donors. We score donors by their track record of finding new high-impact projects, which signal-boosts the projects that they support. Attention from top donors helps you be discovered by more donors, which can snowball into greater and greater fundraising success.
4. If you are a philanthropic funder, we want to make all the local information acc |
1b4dcb04-149a-4618-a77b-22f08b4c53a0 | trentmkelly/LessWrong-43k | LessWrong | The Apparent Reality of Physics
Follow-up to: Syntacticism
I wrote:
> The only objects that are real (in a Platonic sense) are formal systems (or rather, syntaxes). That is to say, my ontology is the set of formal systems. (This is not incompatible with the apparent reality of a physical universe).
In my experience, most people default1 to naïve physical realism: the belief that "matter and energy and stuff exist, and they follow the laws of physics". This view has two problems: how do you know stuff exists, and what makes it follow those laws?
To the first - one might point at a rock, and say "Look at that rock; see how it exists at me." But then we are relying on sensory experience; suppose the simulation hypothesis were true, then that sensory experience would be unchanged, but the rock wouldn't really exist, would it? Suppose instead that we are being simulated twice, on two different computers. Does the rock exist twice as much? Suppose that there are actually two copies of the Universe, physically existing. Is there any way this could in principle be distinguished from the case where only one copy exists? No; a manifest physical reality is observationally equivalent to N manifest physical realities, as well as to a single simulation or indeed N simulations. (This remains true if we set N=0.)
So a true description requires that the idea of instantiation should drop out of the model; we need to think in a way that treats all the above cases as identical, that justifiably puts them all in the same bucket. This we can do if we claim that that-which-exists is precisely the mathematical structure defining the physical laws and the index of our particular initial conditions (in a non-relativistic quantum universe that would be the Schrödinger equation and some particular wavefunction). Doing so then solves not only the first problem of naïve physical realism, but the second also, since trivially solutions to those laws must follow those laws.
But then why should we privilege our par |
171b8fcb-c5da-4934-87b2-6ee99c9213b3 | trentmkelly/LessWrong-43k | LessWrong | MILA gets a grant for AI safety research
http://www.openphilanthropy.org/focus/global-catastrophic-risks/potential-risks-advanced-artificial-intelligence/montreal-institute-learning-algorithms-ai-safety-research
The really good news is that Yoshua Bengio is leading this (he is extremely credible in modern AI/deep learning world), and this is a pretty large change of mind for him. When I spoke to him at a conference 3 years ago he was pretty dismissive of the whole issue; this year's FLI conference seems to have changed his mind (kudos to them)
Of course huge props to OpenPhil for pursuing this |
1ac4f260-ecea-4a6e-a3e4-3fff096428ae | trentmkelly/LessWrong-43k | LessWrong | Why I'm Moving from Mechanistic to Prosaic Interpretability
Tl;dr I've decided to shift my research from mechanistic interpretability to more empirical ("prosaic") interpretability / safety work. Here's why.
All views expressed are my own.
What really interests me: High-level cognition
I care about understanding how powerful AI systems think internally. I'm drawn to high-level questions ("what are the model's goals / beliefs?") as opposed to low-level mechanics ("how does the model store and use [specific fact]?"). Sure, figuring out how a model does modular addition is cool, but only insofar as those insights and techniques generalise to understanding higher-level reasoning.
Mech interp has been disappointing
Vis-a-vis answering these high-level conceptual questions, mechanistic interpretability has been disappointing. IOI remains the most interesting circuit we've found in any language model. That's pretty damning. If mechanistic interpretability worked well, we should have already mapped out lots of interesting circuits in open-source 7B models by now.
The field seems conceptually bottlenecked. We simply can't agree on what 'features' are or how to 'extract' them. I'm also not sure that this conceptual ennui will be resolved anytime soon.
Doing mech interp research led me to update against it
Some time ago, I was pretty optimistic that things would change quickly. After hearing about sparse feature circuits, I became incredibly convinced that approaches like this would 'finally' allow us to understand language models end to end.
So I committed fully to the nascent SAE bandwagon. At a hackathon, I worked on building a tool for visualizing sparse feature circuits. When I got the chance, I threw myself into Neel Nanda's MATS 6.0 training phase, where I similarly worked (with the excellent @jacob_drori) on extending sparse feature circuits with MLP transcoders. Overall there were signs of life, but it turned out kind of mid and my main takeaway was 'existing SAEs might not be good enough to tell us anything use |
84dcd0b7-1838-4e07-bbfb-e416d75bf4a9 | StampyAI/alignment-research-dataset/blogs | Blogs | Matthias Troyer on Quantum Computers
![]() [](http://intelligence.org/wp-content/uploads/2015/01/image.jpg)
[Dr. Matthias Troyer](http://www.itp.phys.ethz.ch/people/troyer) is a professor of Computational Physics at ETH Zürich. Before that, he finished University Studies in “Technischer Physik” at the Johannes Kepler Universität Linz, Austria, as well as Diploma in Physics and Interdisciplinary PhD thesis at the ETH Zürich.
His research interest and experience focuses on High Performance Scientific Simulations on architectures, quantum lattice models and relativistic and quantum systems. Troyer is known for leading the research team of the D-Wave One Computer System. He was awarded an Assistant Professorship by the Swiss National Science Foundation.
**Luke Muehlhauser**: Your tests of D-Wave’s (debated) quantum computer have gotten much attention recently. Our readers can get up to speed on that story via [your arxiv preprint](http://arxiv.org/abs/1401.2910), its [coverage](http://www.scottaaronson.com/blog/?p=1643) at Scott Aaronson’s blog, and [Will Bourne’s article](http://www.inc.com/will-bourne/d-waves-dream-machine.html) for *Inc.* For now, though, I’d like to ask you about some other things.
If you’ll indulge me, I’ll ask you to put on a technological forecasting hat for a bit, and respond to a question I also [asked](http://intelligence.org/2014/02/03/ronald-de-wolf-on-quantum-computing/) Ronald de Wolf: “What is your subjective probability that we’ll have a 500-qubit quantum computer, which is uncontroversially a quantum computer, within the next 20 years? And, how do you reason about a question like that?”
---
**Matthias Troyer:** In order to have an uncontroversial quantum computer as you describe it we will need to take three steps. First we need to have at least ONE qubit that is long term stable. The next step is to couple two such qubits, and the final step is to scale to more qubits.
The hardest step is the first one, obtaining a single long-term stable qubit. Given intrinsic decoherence mechanisms that cannot be avoided in any real device, such a qubit will have to built from many (hundreds to thousands) of physical qubits. These physical qubits will each have a finite coherence time, but they will be coupled in such a way (using error correcting codes) as to jointly generate one long term stable “logical” qubit. These error correction codes require the physical qubits to be better than a certain threshold quality. Recently qubits started to approach these thresholds, and I am thus confident that within the next 5-10 years one will be able to couple them to form a long-time stable logical qubit.
Coupling two qubits is something that will happen on the same time scale. The remaining challenge will thus be to scale to your target size of e.g. 500 qubits. This may be a big engineering challenge but I do not see any fundamental stumbling block given that enough resources are invested. I am confident that this can be achieved is less than ten years once we have a single logical qubit. Overall I am thus very confident that a 500-qubit quantum computer will exist in 20 years.
---
**Luke**: At the present moment, which groups seem most likely to play a significant role in the final development of an early large-scale (uncontroversial) quantum computer?
---
**Matthias:** There is quite a large number of groups that may be involved. The technologies that I see as most promising regarding scalability and quality of qubits are superconducting qubits, topological qubits and ion traps.
---
**Luke**: Now back to your co-authored paper “[Defining and detecting quantum speedup](http://arxiv.org/abs/1401.2910),” now published [in *Science*](http://www.sciencemag.org/content/345/6195/420.abstract). You an your coauthors “found no evidence of quantum speedup [in the D-Wave Two machine] when the entire data set is considered and obtained inconclusive results when comparing subsets of instances on an instance-by-instance basis.”
Do people who have investigated a D-Wave machine at some length tend to think that D-Wave has a “true” quantum computer but hasn’t been able to conclusively show it yet, or do they tend to think D-Wave doesn’t yet have a true quantum computer?
---
**Matthias:** The answer to this controversial question depends on the definition of the words “quantum” and “computer”. Let’s first talk about “computer”. The D-Wave devices are special purpose devices, built for one particular purpose, namely the solution of discrete optimization problems. Since they solve a computational problem they may be called “computers”, but in contrast to your standard personal computers, which can perform many different tasks they are not “universal computers” but special purpose computers. Nowadays many people automatically assume that a “universal computer” is meant when the term computer is mentioned, and one should thus explicitly state that the D-Wave devices are not universal computers but special purpose ones.
D-Wave thus cannot be, and nobody has ever claimed so, to be a universal quantum computer. While nobody would argue against the D-Wave device being called a computer, the question of it being “quantum” is more controversial. In a previous paper in Nature Physics we have presented evidence that the behavior of the D-Wave devices is consistent with that of a “quantum annealer” working at nonzero temperature, and another recent paper has shown that entanglement is present in the devices. The devices hence use quantum effects for computing. However, [another paper](http://arxiv.org/abs/1401.7087) has shown that the behavior of a quantum annealer for the problems on which we tested the device can also be described by a purely classical model. Some people thus argue that while the device may use quantum effects it might in the end be a classical device, just like the CPU in your PC, where the transistors also uses quantum effects at some level.
The important question thus is whether the device can have quantum speedup, which means that it outperforms any classical device by a larger and larger ratio as the size of problems is increased. If that should be shown for some class of problems then nobody would argue about the quantum nature of the device. On the other hand, as long as its computational powers are never more than that of a classical computer, one can argue that from a computational point of view it is effectively a classical device even if it uses quantum effects to arrive at the answer.
To answer your question more concisely. If by a “true quantum computer” you mean a universal quantum computer, then D-Wave is not a true quantum computer and nobody has ever claimed that it is one. If you are content with it being a special purpose quantum computer, i.e. a a “true quantum annealer”, then this question depends on what you mean by “true”: it’s behavior seems to be consistent with what we expect from a quantum annealer, but since we have so far not seen evidence of quantum speedup, i.e. that quantum effects help it outperform classical computers, one can argue that it may effectively be a classical device.
---
**Luke Muehlhauser**: Do you have an opinion about the impact that large-scale quantum computers (universal or not) are likely to have on AI and machine learning methods? E.g. [Aimeur et al. (2013)](http://commonsenseatheism.com/wp-content/uploads/2014/02/Aimeur-et-al-Quantum-speed-up-for-unsupervised-learning.pdf) seems optimistic about speeding up some machine learning methods using variants of [Grover’s algorithm](http://en.wikipedia.org/wiki/Grover%27s_algorithm).
---
**Matthias Troyer:** I haven’t read that specific paper but my sense is that quantum machine learning will be most useful for learning about quantum data that comes out of quantum experiments. Applying quantum algorithms to classical data, even quantum algorithms need to read the data first, and thus cannot do better than linear effort in the size of the data. With efficient polynomial time algorithms existing for many machine learning problems one will have to have better ideas than just speeding up classical machine learning algorithms on quantum hardware.
---
**Luke Muehlhauser**: Thanks, Matthias.
The post [Matthias Troyer on Quantum Computers](https://intelligence.org/2015/01/07/matthias-troyer-quantum-computers/) appeared first on [Machine Intelligence Research Institute](https://intelligence.org). |
27ce4e3c-b084-4e0c-8139-90b10c9ce640 | trentmkelly/LessWrong-43k | LessWrong | Do Antidepressants work? (First Take)
I've been researching the controversy over whether antidepressants truly work or whether they are not superior to a placebo. The latter possibility really contains two possibilities itself: either placebos are effective at treating depression, or the placebo effect reflects mean reversion. Here, the term "antidepressant" refers to drugs classified as SSRIs and SNRIs.
Some stylized facts from the literature of RCTs:
* Both antidepressants and placebos are associated with a reduction in symptoms of depression
* Antidepressants are associated with a larger reduction in depressive symptoms than placebos
* This difference in efficacy is attenuated when "enhanced" placebos are used, that is placebos that are designed to provoke side effects to persuade the subject that they are being treated with a real medication
* Studies on antidepressants broadly measure either an average treatment effect according to some continuous scale or a binary treatment according to a cutoff for success/failure of treatment (or both). Universally, if you looked only at the former measure you would conclude that the effect of antidepressants on depression is clinically insignificant, while if you looked only at the latter measure you would come to a more favorable conclusion.
How is depression measured?
Most studies of antidepressant efficacy use the Hamilton Depression Rating Scale (HDRS) to measure changes in depressive symptoms from the baseline, although entrance into the clinical trials themselves is often not based on this measure. There are several versions of this scale, but the most popular one is HDRS-17, which is a seventeen question survey administered by a clinician. Scores on HDRS-17 vary from zero to 57. Scores of 0-7 are generally considered normal, while a score of 20 or greater indicates at least moderate depression.
You can look at the questions on HDRS-17 here. To my eye, it seems to strangely underweight feelings of subjective psychological distress that define dep |
47474c1f-351c-4d41-8cd0-c3b5389b1620 | trentmkelly/LessWrong-43k | LessWrong | internal in nonstandard analysis
Internal set theory is a theory introduced by Edward Nelson, notably an ultrafinitist. it introduces a new function std: * -> Bool. You have to just know if something is standard or not. This may sound bad, but is actually a brilliant way of venting complexity. Figuring out if something is standard is obvious.
1 is standard.
pi is standard.
1 + epsilon is nonstandard if epsilon is infinitesimal.
a hyperfinite number is nonstandard.
Because this is a syntactic theory, it can’t really distinguish infinitesimal and unlimited elements from regular ones. But we can provide the semantics and just know if something is standard or not.
as long as we stick to internal formulas, this extension transfers to the original axioms.
a function is internal if it treats standard and nonstandard elements the same.
example:
1 + x is internal. no distinction is made on what x is.
(1 if standard else 0) is external aka not internal.
no recursive calls can lead to anything with the term ‘standard‘ in it. in practice, this is also fine.
this trick of interpreting syntax in a larger domain of elements (sometimes called abstract interpretation) is also how dual numbers in autodiff work too. the hyperreals are the dual numbers’ bigger sister.
amazingly, griewank’s autodiff book only mentions nonstd analysis once, for like 2 sentences.
James Bradbury if you’re reading this learn some stuff about the hyperreals and make an autodiff system that can differentiate functions that aren’t even continuous. |
85225add-e03f-4814-8eec-292a686be7e8 | trentmkelly/LessWrong-43k | LessWrong | Blood Feud 2.0
I've been thinking about the idea of culpability.
What is it for, exactly? Why did societies that use the concept win out over those who stuck with the default response of not assigning any particular emotional significance to a given intangible abstraction?
If I'm understanding correctly, a given person can be said to be responsible for a given event if and only if a different decision on the part of that person (at some point prior to the event) would be a necessary condition for the event to have not occurred. So, in a code of laws, statements along the lines of "When X happens, find the person responsible and punish them" act as an incentive to avoid becoming 'the person responsible,' that is, to put some effort into recognizing when a situation where your actions might lead to negative externalities, and to make the decision that won't result in someone, somewhere down the line, getting angry enough to hunt you down and burn you alive.
A person cannot be said to be culpable if they had no choice in the matter, or if they had no way of knowing the full consequences of whatever choice they did have. Recklessness is punished less severely than premeditation, and being provably, irresistably coerced into something is hardly punished at all. The causal chain must be traced back to the most recent point where it was sensitive to a conscious decision in a mind capable of considering the law, because that's the only point where distant deterrence or encouragement could have an effect.
"Ignorance is no excuse" because if it were, any halfway-competent criminal could cultivate scrupulous unawareness and be untouchable, but people think it should be an excuse because the law needs to be predictable to work. Same reason punishing someone for doing what was legal at the time doesn't make sense, except as a power-play.
So, let's say you're a tribal hominid, having just figured out all the above in one of those incommunicable, unrepeatable flashes of brilliance. How d |
2f327a8e-b8ee-4672-80de-d890784bb37f | StampyAI/alignment-research-dataset/blogs | Blogs | Our mid-2014 strategic plan
#### Summary
Events since MIRI’s [April 2013 strategic plan](http://intelligence.org/2013/04/13/miris-strategy-for-2013/) have increased my confidence that we are “headed in the right direction.” During the rest of 2014 we will continue to:
* Decrease our public outreach efforts, leaving most of that work to [FHI](http://www.fhi.ox.ac.uk/) at Oxford, [CSER](http://cser.org/) at Cambridge, [FLI](http://thefutureoflife.org/) at MIT, [Stuart Russell](http://www.cs.berkeley.edu/~russell/research/future/) at UC Berkeley, and others (e.g. [James Barrat](http://www.jamesbarrat.com/)).
* Finish a few pending “strategic research” projects, then decrease our efforts on that front, again leaving most of that work to FHI, plus CSER and FLI if they hire researchers, plus some others.
* Increase our investment in our Friendly AI (FAI) technical research agenda.
The [reasons](http://intelligence.org/2013/04/13/miris-strategy-for-2013/) for continuing along this path remain largely the same, but I have more confidence in it now than I did before. This is because, since April 2013:
* We produced much [Friendly AI research progress](http://intelligence.org/all-publications/) on many different fronts, and do not *remotely* feel like we’ve exhausted the progress that could be made if we had more researchers, demonstrating that the FAI technical agenda is highly tractable.
* FHI, CSER, and FLI have had substantial public outreach success, in part by leveraging their university affiliations and impressive advisory boards.
* We’ve heard that as a result of this outreach success, and also because of Stuart Russell’s discussions with researchers at AI conferences, AI researchers are beginning to ask, “Okay, this looks important, but what is the technical research agenda? What could my students and I *do* about it?” Basically, they want to see an FAI technical agenda, and MIRI is is developing that technical agenda already (see below).
In short, I think we tested and validated MIRI’s new strategic focus, and now it is *time to scale*. Thus, our **top goals** for the next 6-12 months are to:
1. Produce more Friendly AI research.
2. Recruit more Friendly AI researchers.
3. Fundraise heavily to support those activities.
Our low-level tactics for achieving these high-level goals will probably change quickly as we try things and learn, but I’ll sketch our *current* tactical plans below anyway.
#### 1. More Friendly AI research
Our [workshops](http://intelligence.org/research/) have produced much FAI research progress, and they allowed us to recruit our [two new FAI researchers](http://intelligence.org/2014/03/13/hires/) of 2014, but we’ve learned that it’s difficult for “newcomers” (people who haven’t been following the research for a long time) to contribute to FAI research at our workshops. Newcomers need better tutorials and more time to think about the research problems before they can contribute much at the cutting edge (see the next section). Therefore our efforts toward novel research progress in 2014 will focus on:
* Organizing research workshops attended mostly or solely by “veterans” (people who have been following the research for a long time), such as our [May 2014 workshop](http://intelligence.org/workshops/#may-2014).
* Inviting individual researchers to visit MIRI for a few days at a time to work with us on very specific research problems with which they are already familiar.
* Giving our staff FAI researchers time to make theoretical progress on their own and with each other.
#### 2. Recruiting
Here I talk about “recruiting” rather than “creating a field,” but in fact most of the planned activities below accomplish both ends simultaneously, because they find — and help to activate — new FAI researchers. Still, where there’s a steep tradeoff between recruiting and helping to create a field, we focus on recruiting. FAI research is best done as a full-time career with minimal distractions, and right now MIRI is the only place [offering such jobs](http://intelligence.org/careers/research-fellow/).
We plan to try many different things to see what most helps for recruiting:
* We plan to publish an overview of the FAI technical agenda as we see it so far. This should make it easier for potential FAI researchers to engage.
* We plan to prepare, test, improve, and then deliver (in many different cities) a series of tutorials on different parts of the FAI technical agenda. Besides giving tutorial lectures, we may also organize one-day or two-day workshops that are just for tutorials and Q&A sessions rather than being aimed at making novel research progress.
* We plan to release a book version of Yudkowsky’s [*Less Wrong Sequences*](http://wiki.lesswrong.com/wiki/Sequences), in part because we’ve noticed that those who have contributed most to FAI research progress have read — and been influenced by — those writings, and this seems to help when they’re doing FAI research.
* We’ll continue to help fund [SPARC](http://sparc-camp.org/), the lead organizer of which is a frequent MIRI workshop participant (Paul Christiano).
* We’ll continue to fund independently-organized FAI workshops via our [MIRIx program](http://intelligence.org/mirix/).
* We may offer widely-advertised cash prizes for certain kinds of research progress, e.g. a winning decision algorithm submitted to a [robust program equilibrium](http://arxiv.org/abs/1401.5577) tournament, or a certain kind of solution to the [Löbian obstacle](https://intelligence.org/files/ProblemsofSelfReference.pdf).
* We may advertise in venues such as *Notices of the AMS* (widely read by mathematicians) and *Communications of the ACM* (widely read by computer scientists).
* We’re in discussion with development staff at UC Berkeley about a variety of potential MIRI-Berkeley collaborations that could make it easier for researchers to collaborate heavily with MIRI from within a leading academic institution.
We’ve also made our [job offer to FAI researchers](http://intelligence.org/careers/research-fellow/) more competitive.
#### 3. Fundraising
To support our growing Friendly AI research program, we’ve set a “stretch” goal to [raise $1.7 million in 2014](http://intelligence.org/2014/04/02/2013-in-review-fundraising/).
To reach toward that goal, we [participated in SV Gives](http://intelligence.org/2014/05/06/liveblogging-the-svgives-fundraiser/) on May 6th and raised ~$110,000, and also won ~$61,000 in matching and prizes from sources that otherwise wouldn’t have donated to MIRI. Our thanks to everyone who donated!
As usual, we’ll also run our major summer and winter fundraising drives, starting in July and December respectively.
This year we’ll explore the possibility of corporate sponsorships, but we are not optimistic about that strategy, because MIRI’s work has little near-term commercial relevance, and we’ve been counseled that corporate sponsors often require more in return from a sponsored organization than the funds are worth.
We’re more optimistic about the potential returns from improving our donor stewardship and donor prospecting, which we’ve already begun, and we’re seeking to hire a [full-time Director of Development](http://intelligence.org/careers/director-of-development/).
Donor prospecting is unlikely to result in new donors in 2014, but will be important for future fundraising years. This is also the case for our recent efforts to find and apply for grants from both private and public grantmakers. We don’t expect to win much in grants in 2014, but we expect to learn in detail what else we need to do over the next couple years so that we can win large grants in the future, and thereby diversify our funding sources.
The post [Our mid-2014 strategic plan](https://intelligence.org/2014/06/11/mid-2014-strategic-plan/) appeared first on [Machine Intelligence Research Institute](https://intelligence.org). |
50756936-2b79-40fe-a3c6-acd314ee16a3 | trentmkelly/LessWrong-43k | LessWrong | Rationality Quotes 2
"I often have to arrange talks years in advance. If I am asked for a title, I suggest “The Current Crisis in the Middle East.” It has yet to fail."
-- Noam Chomsky
"We don't do science for the general public. We do it for each other. Good day."
-- Renato Dalbecco, complete text of interview with H F Judson
"Most witches don't believe in gods. They know that the gods exist, of course. They even deal with them occasionally. But they don't believe in them. They know them too well. It would be like believing in the postman."
-- Terry Pratchett, Witches Abroad
"He didn't reject the idea so much as not react to it and watch as it floated away."
-- David Foster Wallace, Infinite Jest
"People can't predict how long they will be happy with recently acquired objects, how long their marriages will last, how their new jobs will turn out, yet it's subatomic particles that they cite as "limits of prediction." They're ignoring a mammoth standing in front of them in favor of matter even a microscope would not allow them to see."
-- Nassim Taleb, The Black Swan
"I would strongly challenge the notion of “that's what's called growing up.” The most depressing part of the nomenclature around adolescence and college life is this bizarre connection between “experimentation” / “learning from your mistakes” and binge drinking, reckless sex, and drug use."
-- Ben Casnocha
"Behind every story of extraordinary heroism, there is a less exciting and more interesting story about the larger failures that made heroism necessary in the first place."
-- Black Belt Bayesian
"Anyone who claims that the brain is a total mystery should be slapped upside the head with the MIT Encyclopedia of the Cognitive Sciences. All one thousand ninety-six pages of it."
-- Tom McCabe
"Try explaining anything scientific to your friends -- you soon won't have any."
-- Soloport
"The definition of the word "meaning," is something that is con |
0efa8ed5-c711-447b-abff-3fbb75b4e0a6 | trentmkelly/LessWrong-43k | LessWrong | Instant stone (just add water!)
Originally posted on The Roots of Progress, January 6, 2018
From the time that humans began to leave their nomadic ways and live in settled societies about ten thousand years ago, we have needed to build structures: to shelter ourselves, to store our goods, to honor the gods.
The easiest way to build is with dirt. Mud, clay, any kind of earth. Pile it up and you have walls. A few walls and a thatched roof, and you have a hut.
Earthen hut with thatched roof in Sudan - Petr Adam Dohnálek / Wikimedia
But earthen construction has many shortcomings. Dirt isn’t very strong, so you can’t build very high or add multiple stories. It tends to wash away in the rain, so it really only works in hot, dry climates. And it can be burrowed through by intruders—animal or human.
We need something tougher. A material that is hard and strong enough to weather any storm, to build high walls and ceilings, to protect us from the elements and from attackers.
Stone would be ideal. It is tough enough for the job, and rocks are plentiful in nature. But like everything else in nature, we find them in an inconvenient form. Rocks don’t come in the shape of houses, let alone temples. We could maybe pile or stack them up, if only we had something to hold them together.
If only we could—bear with me now as I indulge in the wildest fantasy—pour liquid stone into molds, to create rocks in any shape we want! Or—as long as I’m dreaming—what if we had a glue that was as strong as stone, to stick smaller rocks together into walls, floors and ceilings?
This miracle, of course, exists. Indeed, it may be the oldest craft known to mankind. You already know it—and you probably think of it as one of the dullest, most boring substances imaginable.
I am here to convince you that it is pure magic and that we should look on it with awe.
It’s called cement.
----------------------------------------
Let’s begin at the beginning. Limestone is a soft, light-colored rock with a grainy texture, which fizzes in |
2ca77c33-3d0c-42a2-b3e0-2f4524645eae | trentmkelly/LessWrong-43k | LessWrong | Playing the Meta-game
In honor of today's Schelling-pointmas, a true Schelling-inspired story from a class I was in at a law school I did not attend:
As always, the class was dead silent as we walked to the front of the room. The professor only described the game after the participants had volunteered and been chosen; as a result, we rarely were familiar with the games we were playing, which the professor preferred because his money was on the line.
Both of us were assigned different groups of seven partners in the class. I was given seven slips of paper and my opponent was given six. Our goal was to make deals with our partners about how to divide a dollar, one per partner, and then write the deal down on a slip of paper. Whoever had a greater total take from the deals won $20. All negotiations were public.
The professor left the room, giving us three minutes to negotiate. The class exploded.
And then I hit a wall. Everybody with whom I was negotiating knew the rules, and they knew that I cared a hell of a lot more about the results of the negotiation than they did. I was getting offers on the order of $.20 and less--results straight from the theory of the ultimatum game--and no amount of begging or threatening was changing that.
Three minutes pass quickly under pressure. When the professor returned, I had written a total of $1.45 in deals: most people eventually accepted my meta-argument that they really didn't want to carry small coins around with them, so they should give me a quarter and take three for themselves, but two people waited until the last second and took 90 cents each. Even then, I only got ten cents from those two by threatening not to accept one- or five-cent deals.
My opponent, on the other hand, had amassed a relative fortune: over five dollars. It turned out that he had been using the fact that he could make fewer deals than he had partners to auction off the chance to make a deal. His partners kept naming lower and lower demands, and he ended up ge |
ad971652-a5b3-475f-a3f4-3e2c9c5b0ffe | trentmkelly/LessWrong-43k | LessWrong | Harry Potter and the Methods of Rationality Bookshelves
A while back in the Columbus Rationality group, we started wondering: What books would the Harry Potter and the Methods of Rationality houses have in each of their libraries? We had fun categorizing different subjects:
* Gryffindor - Combat, ethics, and justice
* Ravenclaw - Philosophy, cognitive science, and math
* Slytherin -Influence and power
* Hufflepuff - Happiness, productivity, and friendship
And so, I found myself taking all my books off their shelves this weekend and picking the best to represent each rationality!House and made them into Facebook cover-image-sized pictures. Click each image to see it larger, with a list on the left:
(first posted at Measure of Doubt)
I’m always open to book recommendations and suggestions for good fits. What other books would be especially appropriate for each shelf? |
9e79a248-bebd-435c-bc7a-d6bfcae3b444 | trentmkelly/LessWrong-43k | LessWrong | Sudden Future Singularity (SFS) as soon as 8.7 million years in the future?
No, not the kind of Singularity usually discussed here... I'm referring to the possibility of phantom energy-driven rips in the cosmos caused by accelerating expansion, or "sudden future singularities of pressure". (Technically: "a momentary infinite peak in the tidal forces of the universe.") A recent paper by Ghodsi & Hendri shows that cosmic microwave background, baryon acoustic oscillations (BAO), and type 1a supernovae data is consistent with the possibility of a sudden future singularity as soon as 8.7 million years from now.
"Cosmological tests of sudden future singularities"
http://arxiv.org/pdf/1201.6661v1.pdf
As I understand it, the authors are not saying that a SFS is likely 8.7 million years from now, just possible. This puts a dampener on the notion that the only plausible scenario of cosmological breakdown is Heat Death.
Here's another paper that outlines other exotic cosmological singularities which have been under discussion in the cosmology community for the past decade, and the behavior of pointlike particles and strings as they approach such singularities. |
1f5c7a2a-112d-4ad2-ae86-67aa1fac0425 | StampyAI/alignment-research-dataset/arxiv | Arxiv | Evidence with Uncertain Likelihoods
1 Introduction
---------------
Consider an agent trying to choose among a number of hypotheses: Is it
the case that all ravens are black or not?
Is a particular coin fair or double-headed?
The standard picture in such situations is that the agent makes a
number of observations, which give varying degrees of *evidence*
for or against each of the hypotheses.
The following simple example illustrates the situation.
###### Example 1.1
Suppose that Alice and Bob each have a
coin. Alice’s coin is double-headed, Bob’s coin is fair. Charlie knows
all of this. Alice and Bob give their coin to some third party, Zoe,
who chooses one of the coins, and tosses it. Charlie is not privy to
Zoe’s choice, but gets to see the outcome of the toss. Charlie is
interested in two events (which are called hypotheses in this context):
* A: the coin is Alice’s coin
* B: the coin is Bob’s coin.
Now
Charlie
observes the coin land heads. What can he say about the probability
of the events A and B?
If Charlie has no prior probability on A and B, then
he can draw no conclusions about their posterior probability;
the probability of A could be any number in [0,1].
The same remains true if the coin lands heads 100 times in a row.
Clearly Charlie learns something from seeing 100 (or even one)
coin toss land heads. This has traditionally been modeled in terms of
evidence: the more times Charlie sees heads, the more evidence he
has for the coin being double-headed.
A number of ways of have been proposed for
modeling
and quantifying
evidence in the literature; see [[KyburgKyburg1983](#bib.bibx7)] for an
overview.
We do not want to enter the debate here as to which approach is best.
Rather, we focus on a different problem regarding evidence, which seems
not to have been considered before.
All of the approaches to evidence considered in the literature
make use of the likelihood function. More precisely, they assume
that for each hypothesis h of interest, there is a probability μh
(called a likelihood function)
on the space of possible observations. In the example above, if the
coin is tossed once, the two possible observations are heads and
tails. Clearly μA(heads)=1/2 and μB(heads)=1.
If the coin is tossed 100 times, then there are 2100 possible
observations (sequences of coin tosses). Again, μA and μB put
obvious probabilities on this space. In particular, if 100heads is the
observation of seeing 100 heads
in a row, then μA(100heads)=1/2100 and
μB(100heads)=1.
Most of the approaches compute the relative
weight of
evidence of a particular observation ob for two hypotheses A and
B by comparing μA(ob) and μB(ob).
However, in many situations of interest in practice, the
hypothesis h does not determine a unique likehood function μh.
To understand the issues that arise, consider
the following somewhat contrived variant of Example [1.1](#S1.Thmtheorem1 "Example 1.1 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.").
###### Example 1.2
Suppose that
Alice has two coins, one that is double-headed and one that is biased 3/4
towards heads, and chooses which one to give Zoe.
Bob still has only one coin, which is fair.
Again, Zoe
chooses either Alice’s coin or Bob’s coin and tosses it. Charlie, who
knows the whole setup, sees the coin land heads. What does this
tell him about the likelihood that the coin tossed was Alice’s?
The problem is that now we do not have a probability μA on
observations corresponding to the coin being Alice’s coin, since Charlie
does not know if Alice’s coin is double-headed or biased 3/4
towards heads. It seems that there is an obvious solution to this
problem. We simply split the hypothesis “the coin is Alice’s coin”
into two hypotheses:
* A1: the coin is Alice’s coin and it is double-headed
* A2: the coin is Alice’s coin and it is the biased coin.
Now we can certainly apply standard techniques for computing evidence to
the three hypotheses A1, A2, and B. The question now is what do
the answers tell us about the evidence in favor of the coin being
Alice’s coin?
More generally, how should we model and quantify evidence when the
likelihood functions themselves are uncertain?
While Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") is admittedly contrived, situations
like it arise frequently in practice.
For example, Epstein and Schneider \citeyearr:epstein05a show how multiple
likelihoods can arise in investment decisions in the stock market, and
the impact they can have on hedging strategies.111Epstein and Schneider present a general model of decision
making in the presence of multiple likelihoods, although they do not
attempt to quantify the evidence provided by observations in the
presence of multiple likelihoods.
For
another
example, consider a robot equipped with an unreliable
sensor for navigation. This sensor returns the distance to the wall
in front of the robot, with some known error. For simplicity, suppose
that distances are measured in integral units
0,1,2,…, and that if the wall is at distance m, then the
sensor will return a reading of m−1 with probability 1/4, a
reading of m with probability 1/2, and a reading of m+1 with
probability 1/4.
Suppose the robot wants to stop if it is exactly
close to the wall, where “close” is interpreted as being within 3
units of the wall, and go forward if it is farther than 3 units.
So again, we have two hypotheses of interest.
However, while for each specific distance m we have a
probability μm on sensor readings, we do not have a probability on
sensor readings corresponding to the hypothesis far: “the robot is
farther than 3 from the wall”. While standard techniques will certainly
give us the weight of evidence of a particular sensor reading for the
hypothesis “the robot is distance m from the wall”, it is not clear
what the weight of evidence should be for the hypothesis far.
We hope that these examples have convinced the reader that there is
often likely to be uncertainty about likelihoods. Moreover, as we show
by considering one particular definition of evidence, there are
subtleties involved in defining evidence when there is uncertainty about
likelihoods.
Although we focus on only one way of defining evidence,
we believe that these subtleties will arise no matter how evidence is
represented, and that our general approach to dealing with the problem
can be applied to other approaches (although we have not checked the
details).
The approach for determining the weight of evidence
that
we consider in
this paper is due to Shafer \citeyearr:shafer82,
and is a generalization of a method advocated by Good
\citeyearr:good50.
The idea is to assign to every observation and hypothesis a number
between 0 and 1—the weight of evidence for the hypothesis
provided by the observation—that represents how much the observation
supports the hypothesis.
The closer a weight is to 1, the more the observation
supports the hypothesis.
This weight of evidence is computed using the likelihood functions
described earlier.
This way of computing the weight of evidence has several good
properties, and is related to Shafer’s theory of belief functions
[[ShaferShafer1976](#bib.bibx8)]; for instance, the theory gives a way to combine the
weight of evidence from independent observations.
We give full details in Section [2](#S2 "2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.").
For now, we illustrate how the problems described above manifest
themselves in Shafer’s setting.
Let an evidence space E consist of
a set H of possible hypotheses, a set O of observations, and a
probability μh on observations for each h∈H. We take the
weight of evidence
for hypothesis h provided by observation ob in evidence space E,
denoted
wE(ob,h), to be
| | | |
| --- | --- | --- |
| | wE(ob,h)=μh(ob)∑h′∈Hμh′(ob). | |
It is easy to see that wE(ob,⋅) acts like a probability on
H, in that ∑h∈HwE(ob,h)=1.
With this definition, it is easy to compute the weight of evidence for
Alice’s coin when Charlie sees heads in Example [1.1](#S1.Thmtheorem1 "Example 1.1 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") is 2/3, and
the weight of evidence when Charlie sees 100 heads is 2100/(2100+1). As expected, the more often Charlie sees heads, the more
evidence he has in favor of the coin being double-headed (provided that
he does not see tails).
In Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), if we consider the three hypotheses
A1, A2, and B, then the weight of evidence for A1 when
Charlie sees heads is 1/(1+3/4+1/2)=4/9; similarly, the
weight of evidence for A2 is 1/3 and the weight of evidence for B
is 2/9. Since weight of evidence acts like a probability, it might
then seem reasonable to take the weight of evidence for A (the coin
used was Alice’s coin) to be 4/9+1/3=7/9. (Indeed, this approach
was implicitly suggested in our earlier paper [[Halpern and PucellaHalpern and
Pucella2006](#bib.bibx6)].)
But is this reasonable? A first hint that it might not be is the
observation that the weight of evidence for A is higher in this case
than it is in the case where Alice certainly had a double-headed coin.
To analyze this issue, we need an independent way of understanding what
evidence is telling us. As observed by Halpern and Fagin
\citeyearr:halpern92b,
weight of evidence can be viewed as a function from priors to
posteriors. That is, given a prior on hypotheses, we can combine the
prior with the weight of evidence to get the posterior.
In particular, if there are two hypotheses, say H1 and H2, the weight
of evidence for H1 is α, and the prior probability of H1 is
β, then the posterior probability of H1 (that is, the probability
of H1 in light of the evidence) is
| | | |
| --- | --- | --- |
| | αβαβ+(1−α)(1−β). | |
Thus, for example, by deciding to perform an
action when the weight of evidence for A is 2/3 (i.e., after Charlie
has seen the coin land heads once), Charlie is assured
that, if the prior probability of A is at least .01, then the
posterior probability of A is at least 2/11; similarly, after
Charlie has seen 100 heads, if the prior probability of A is at least
.01, then the posterior probability of A is at least
2100/(2100+99).
But now consider the situation in Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."). Again, suppose
that the prior
probability of A is at least .01. Can we conclude that the posterior
probability of A is at least .01(7/9)/(.01(7/9)+.99(2/9))=7/205?
As we show, we cannot. The calculation (αβ)/(αβ+(1−α)(1−β)) is appropriate only when there are two hypotheses.
If the hypotheses A1 and A2 have priors α1 and α2
and weights of evidence β1 and β2, then the posterior
probability of A is
| | | |
| --- | --- | --- |
| | α1β1+α2β2α1β1+α2β2+(1−α1−α2)(1−β1−β2), | |
which is in general quite different from
| | | |
| --- | --- | --- |
| | (α1+α2)(β1+β2)(α1+α2)(β1+β2)+(1−α1−α2)(1−β1−β2). | |
Moreover, it is easy to show that if
β1>β2 (as is the case here), then the posterior of A is
somewhere in the interval
| | | |
| --- | --- | --- |
| | [α2β2α2β2+(1−α2)(1−β2),α1β1α1β1+(1−α1)(1−β1)]. | |
That is, we get a lower bound on the posterior by acting as if the
only possible hypotheses are A2 and B, and we get an upper bound
by acting as if the only possible hypotheses are A1 and B.
In this paper, we generalize this observation by providing a general
approach to dealing with weight of evidence when the likelihood function
is unknown. In the special case when the likelihood function is known,
our approach reduces to Shafer’s approach.
Roughly speaking, the idea is to consider all possible evidence spaces
consistent with the information. The intuition is that one of them is
the right one, but the agent trying to ascribe a weight of evidence does
not know which. For example, in Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."),
the evidence space either involves hypotheses {A1,B}
or hypotheses {A2,B}: either Alice’s first coin is used or Alice’s
second coin is used. We can then compute the weight of evidence for
Alice’s coin being used with respect to each evidence space. This gives
us a range of possible weights of evidence, which can be used for decision
making in a way that seems most appropriate for the problem
at hand (by considering the max, the min, or some other function of the
range).
The advantage of this approach is that it allows us to consider cases
where there are correlations between the likelihood functions.
For example, suppose that, in the robot example, the robot’s sensor was
manufactured at one of two factories. The sensors at factory 1 are more
reliable than those of factory 2.
Since the same
sensor is used for all readings, the appropriate evidence space
either uses all likelihood functions corresponding to factory 1
sensors, or all likelihood functions corresponding to factory 2
sensors.
The rest of this paper is organized as follows.
In Section [2](#S2 "2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), we review Shafer’s approach to dealing
with evidence. In Section [3](#S3 "3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), we show how to
extend it so as to deal with situation where the likelihood function is
uncertain, and argue that our approach is reasonable. In
Section [4](#S4 "4 Combining Evidence ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), we consider how to combine evidence in this
setting. We conclude in Section [5](#S5 "5 Conclusion ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.").
The proofs of our technical results are deferred to the
appendix.
2 Evidence: A Review
---------------------
We briefly review the notion of evidence and its formalization by
Shafer \citeyearr:shafer82, using some terminology from
[[Halpern and PucellaHalpern and
Pucella2005](#bib.bibx5)].
We start with a finite set H of hypotheses, which we take to be mutually
exclusive and exhaustive; thus, exactly one hypothesis holds at any
given time. We also have a set O of *observations*, which
can be understood as outcomes of experiments that can be made.
Finally, we assume that for each hypothesis h∈H, there is a
probability μh (often called a *likelihood function*) on the
observations in O.
This is formalized as an *evidence space* E=(H,O,μ),
where H and O are as above, and μ is a *likelihood
mapping*, which assigns
to every hypothesis h∈H a probability
measure μ(h)=μh. (For simplicity, we often write μh for
μ(h), when the former is clear from context.)
For an evidence space E, the weight of evidence for hypothesis
h∈H provided by observation ob, written wE(ob,h), is
| | | | |
| --- | --- | --- | --- |
| | wE(ob,h)=μh(ob)∑h′∈Hμh′(ob). | | (1) |
The weight of evidence wE provided by
an observation ob with ∑h∈Hμh(ob)=0 is left
undefined by ([1](#S2.E1 "(1) ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")).
Intuitively, this means that the
observation ob is impossible. In the literature on
evidence it is typically assumed that this case never
arises. More precisely, it is assumed that all observations are
possible, so that for every observation ob, there is an hypothesis
h such that
μh(ob)>0. For simplicity, we make the same assumption
here. (We remark that in some application domains this assumption holds
because of the structure of the domain, without needing to be assumed
explicitly; see [[Halpern and PucellaHalpern and
Pucella2005](#bib.bibx5)] for an example.)
The measure wE always lies between 0 and 1, with 1 indicating
that the observation provides full evidence for the hypothesis.
Moreover, for each fixed observation ob for which
∑h∈Hμh(ob)>0, ∑h∈HwE(ob,h)=1, and
thus the weight of evidence wE looks like a probability measure
for each ob. While this has some useful technical consequences, one
should not interpret wE as a probability measure. It is simply a
way to assign a weight to hypotheses given observations, and, as we
shall soon see, can be seen as a way to update a prior probability on
the hypotheses into a posterior probability on those hypotheses,
based on the observations made.
###### Example 2.1
In Example [1.1](#S1.Thmtheorem1 "Example 1.1 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), the set
H of hypotheses is {A,B};
the set O of observations is simply {heads,tails}, the
possible
outcomes of a coin toss. From the
discussion following the description of the example, it follows that
μ assigns the following likelihood functions to the
hypotheses: since μA(heads) is the probability that the coin
landed heads if it is Alice’s coin (i.e., if it is double-headed), then
μA(heads)=1 and μA(tails)=0. Similarly,
μB(heads) is the probability that the coin lands heads if it
is fair, so μB(heads)=1/2 and μB(tails)=1/2. This can
be summarized by the following table:
| μ | A | B |
| --- | --- | --- |
| heads | 1 | 1/2 |
| tails | 0 | 1/2 |
Let
| | | |
| --- | --- | --- |
| | E=({A,B},{heads,tails},μ). | |
A straightforward computation shows that wE(heads,A)=2/3 and
wE(heads,B)=1/3. Intuitively, the coin landing heads
provides more evidence for the hypothesis A
than the hypothesis B. Similarly, w(tails,A)=0 and
w(tails,A)=1. Thus, the coin landing tail indicates that the
coin must be fair. This information can be represented by the
following table:
| wE | A | B |
| --- | --- | --- |
| heads | 2/3 | 1/3 |
| tails | 0 | 1 |
It is possible to interpret the weight function w as a prescription
for how to update a prior probability on the hypotheses into a
posterior probability on those hypotheses, after having considered the
observations made [[Halpern and FaginHalpern and
Fagin1992](#bib.bibx4)].
There is a precise sense in which wE can be viewed as a
function that maps a prior probability μ0 on the hypotheses H
to a posterior probability μob based on observing ob, by
applying Dempster’s Rule of Combination [[ShaferShafer1976](#bib.bibx8)]. That is,
| | | | |
| --- | --- | --- | --- |
| | μob=μ0⊕wE(ob,⋅), | | (2) |
where ⊕ combines two probability distributions on H to get a new
probability distribution on H as follows:
| | | | |
| --- | --- | --- | --- |
| | (μ1⊕μ2)(H)=∑h∈Hμ1(h)μ2(h)∑h∈Hμ1(h)μ2(h). | | (3) |
(Strictly speaking, ⊕ is defined for set functions, that is,
functions with domain 2H. We have defined wE(ob,⋅) as
a function with domain H, but is is clear from ([3](#S2.E3 "(3) ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."))
that this is all that is really necessary to compute μ0⊕wE(ob,⋅) in our case.)
Note that ([3](#S2.E3 "(3) ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")) is not defined if ∑h∈Hμ1(h)μ2(h)=0—this means that the update ([2](#S2.E2 "(2) ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."))
is not defined when the weight of evidence
provided by observation ob all goes for an hypothesis h with
prior probability μ0(h)=0
Bayes’ Rule is the standard way of updating a prior probability
based on an observation, but it is only applicable when we have a
joint probability distribution on both the hypotheses and the
observations, something which we did not assume we had.
Dempster’s Rule of Combination essentially “simulates” the effects of
Bayes’s rule.
The relationship between Dempster’s Rule and Bayes’ Rule is made precise
by the following well-known theorem.
###### Proposition 2.2
[[Halpern and FaginHalpern and
Fagin1992](#bib.bibx4)]
Let E=(H,O,μ) be an evidence
space. Suppose that P is a probability on H×O such that
P(H×{ob}|{h}×O)=μh(ob) for all h∈H and
all ob∈O.
Let μ0 be the probability on H induced by marginalizing
P; that is,
μ0(h)=P({h}×O).
For ob∈O, let μob=μ0⊕wE(ob,⋅). Then
μob(h)=P({h}×O|H×{ob}).
In other words, when we do have a joint probability on the hypotheses
and observations, then Dempster’s Rule of Combination gives us the
same result as a straightforward application of Bayes’ Rule.
3 Evidence with Uncertain Likelihoods
--------------------------------------
In Example [1.1](#S1.Thmtheorem1 "Example 1.1 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), each of the two hypotheses A and B determines
a likelihood function. However, in Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."),
the hypothesis A does not determine a likelihood function.
By viewing it as the compound hypothesis {A1,A2}, as we did in
the introduction, we can construct an evidence space with a
set {A1,A2,B} of hypotheses.
We then
get the following likelihood mapping μ:
| μ | A1 | A2 | B |
| --- | --- | --- | --- |
| heads | 1 | 3/4 | 1/2 |
| tails | 0 | 1/4 | 1/2 |
Taking
| | | |
| --- | --- | --- |
| | E=({A1,A2,B},{heads,tails},μ), | |
we can compute the following weights of evidence:
| wE | A1 | A2 | B |
| --- | --- | --- | --- |
| heads | 4/9 | 1/3 | 2/9 |
| tails | 0 | 1/3 | 2/3 |
If we are now given prior probabilities for A1, A2, and B,
we can easily use Proposition [2.2](#S2.Thmtheorem2 "Proposition 2.2 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") to compute posterior
probabilities for each of these events, and then add the posterior
probabilities of A1 and A2 to get a posterior probability for A.
But what if we are given only a prior probability μ0 for A and
B, and are not given probabilities for A1 and
A2? As observed in the introduction, if we define
wE(heads,A)=wE(heads,A1)+wE(heads,A2)=7/9, and then try to
compute the posterior probability of A given that heads is observed
by naively applying the equation in Proposition [2.2](#S2.Thmtheorem2 "Proposition 2.2 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), that
is, taking by μheads(A)=(μ0⊕wE(heads,⋅))(A), we get an inappropriate answer. In
particular, the answer is not the posterior probability in general.
To make this concrete, suppose that μ0(A)=.01.
Then, as observed in the introduction, a naive application of this
equation suggests that the posterior probability of A is 7/205.
But suppose that in fact μ0(A1)=α for some α∈[0,.01]. Then applying Proposition [2.2](#S2.Thmtheorem2 "Proposition 2.2 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), we see that
μheads(A1)=α(4/9)/(α(4/9)+(.01−α)(1/3)+.99(2/9)=4α/(α+2.01). It is easy to check that
4α/(α+2.01)=7/205 iff α=1407/81300.
That is, the naive application of the equation in
Proposition [2.2](#S2.Thmtheorem2 "Proposition 2.2 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") is correct only if we assume a particular
(not terribly reasonable) value for the prior probability of A1.
We now present one approach to dealing with the problem, and argue that
it is reasonable.
Define a *generalized evidence space* to be a tuple
G=(H,O,Δ), where Δ is a finite set
of likelihood mappings.
As we did in Section [2](#S2 "2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), we assume that every
μ∈Δ makes every observation possible: for all
μ∈Δ and all observations ob, there is an hypothesis h
such that μ(h)(ob)>0.
Note for future reference that we can
associate
with the generalized evidence space G=(H,O,Δ)
the set S(G)={(H,O,μ)∣μ∈Δ} of evidence
spaces. Thus, given a generalized evidence space G, we can define
the *generalized weight of evidence* wG to be the set {wE:E∈S(G)} of weights of evidence.
We often treat wG as a set-valued function, writing
wG(ob,h) for {w(ob,h)∣w∈wG}.
Just as we can combine a prior with the weight of evidence to get a
posterior in a standard evidence spaces, given a generalized
evidence space, we can combine a prior with a generalized weight of evidence to
get a set of posteriors.
Given a prior probability μ0 on a set H of
hypotheses and a generalized weight of evidence
wG,
let Pμ0,ob be the set of posterior probabilities on H
corresponding to an observation ob
and prior μ0,
computed according to Proposition [2.2](#S2.Thmtheorem2 "Proposition 2.2 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."):
| | | | |
| --- | --- | --- | --- |
| | Pμ0,ob={μ0⊕w(ob,⋅)∣w∈wG,μ⊕w(ob,⋅) defined}. | | (4) |
Since μ0⊕w(ob,⋅) need not always exist for a given
w∈wG, the set Pμ0,ob is made up only of those
μ0⊕w(ob,⋅) that do exist.
###### Example 3.1
The generalized evidence space for Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), where Alice’s
coin is unknown, is
| | | |
| --- | --- | --- |
| | G=({A,B},{heads,tails},{μ1,μ2}), | |
where μ1(A)=μA1, μ2(A)=μA2, and
μ1(B)=μ2(B)=μB.
Thus, the first likelihood mapping corresponds to
Alice’s coin
being
double-headed, and the second corresponds to Alice’s coin
being biased 3/4 towards heads. Then wG={w1,w2}, where
w1(heads,A)=2/3 and w2(heads,A)=3/5.
Thus, if μ0(A)=α, then
Pμ0,heads(A)={3αα+2,2αα+1}.
We have now given two approaches for capturing the situation in
Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."). The first involves refining the set of hypotheses
—that is, replacing the hypothesis A by A1 and A2—and
using a standard evidence space. The second involves using a
generalized evidence space. How do they compare?
To make this precise, we need to first define what a refinement is.
We say that the evidence space (H′,O,μ′) *refines*, or
*is a refinement of*, the generalized evidence space
(H,O,Δ)
*via g*
if g:H′→H is a surjection
such that μ∈Δ if and only if, for all h∈H, there exists some h′∈g−1(h) such that μ(h)=μ′(h′).
For example, the evidence space E at the beginning of this section
(corresponding to Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")) is a refinement of the
generalized evidence space G in Example [3.1](#S3.Thmtheorem1 "Example 3.1 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")
via the surjection g:{A1,A2,B}→{A,B} that maps
A1 and
A2 to A and B to B.
It is almost immediate from the definition of refinement that
(H′,O,μ′) refines (H,O,Δ) only if Δ has a
particularly simple structure.
###### Proposition 3.2
If (H′,O,μ′) refines (H,O,Δ) via g,
then Δ=∏h∈HPh, where
Ph={μ′(h′)∣h′∈g−1(h)}.
Intuitively, each hypothesis h∈H is refined to the set of
hypotheses g−1(h)⊆H′; moreover, each likelihood
function μ(h) in a likelihood mapping μ∈Δ is the
likelihood function μ′(h′) for some hypothesis h′ refining
h.
A prior μ′0 on H′ *extends* a prior μ0 on
H if for all h,
| | | |
| --- | --- | --- |
| | μ′0(g−1(h))=μ0(h). | |
Let
Ext(μ0) consist of all priors on H′ that extend μ0.
Recall that, given a set P of probability measures, the *lower
probability* P∗(U) of a set U is inf{μ(U)∣μ∈P} and its *upper probability* P∗(U) is
sup{μ(U)∣μ∈P}
[[HalpernHalpern2003](#bib.bibx3)].
###### Proposition 3.3
Let E=(H′,O,μ′) be a refinement of the generalized evidence
space G=(H,O,Δ) via g.
For all ob∈O and all h∈H,
we have
| | | |
| --- | --- | --- |
| | (Pμ0,ob)∗(h)={μ′0⊕wE(ob,⋅)∣μ′0∈Ext(μ0)}∗(g−1(h)) | |
and
| | | |
| --- | --- | --- |
| | (Pμ0,ob)∗(h)={μ′0⊕wE(ob,⋅)∣μ′0∈Ext(μ0)}∗(g−1(h)). | |
In other words, if we consider the sets of posteriors obtained by
either (1) updating a prior probability μ0 by the generalized
weight of evidence of an observation in G or (2) updating
the set of priors extending μ0 by the weight of evidence of
the same observation in E, the bounds on those two sets are the
same.
Therefore, this
proposition shows that, given a generalized evidence space G,
if there an evidence space E that refines it, then the weight of
evidence wG gives us essentially the same information as
wE. But is there always an evidence space E that refines a
generalized evidence space?
That is, can we always understand a generalized weight of evidence in
terms of a refinement?
As we now show, we cannot always do this.
Let G be a generalized evidence space (H,O,Δ).
Note that if E refines G then, roughly
speaking, the likelihood mappings in Δ consist of all possible
ways of combining the likelihood functions corresponding to the
hypotheses in H. We now formalize this property.
A set Δ of likelihood mappings is *uncorrelated* if there
exist sets of
probability measures Ph for each h∈H such that
| | | |
| --- | --- | --- |
| | Δ=∏h∈HPh={μ∣μ(h)∈Ph for all h∈H}. | |
(We say Δ is *correlated* if it is not uncorrelated.)
A generalized evidence space (H,O,Δ) is uncorrelated if
Δ is uncorrelated.
Observe that if (H′,O,μ′) refines (H,O,Δ)
via g,
then (H,O,Δ) is uncorrelated since, by Proposition [3.2](#S3.Thmtheorem2 "Proposition 3.2 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."),
Δ=∏h∈HPh, where Ph={μ′(h′)∣h′∈g−1(h)}. Not only is every refinement uncorrelated, but every
uncorrelated evidence space can be viewed as a refinement.
###### Proposition 3.4
Let G be a generalized evidence space. There exists an evidence
space E that refines G if and only if G is uncorrelated.
Thus,
if a situation can be modeled using an uncorrelated
generalized evidence space, then it can also be modeled by refining
the set of hypotheses and using a simple evidence space.
The uncorrelated case has a further advantage. It leads to simple
formula for calculating the posterior in the special case that there are
only two hypotheses (which is the case that has been considered most
often in the literature, often to the exclusion of other cases).
Given a generalized evidence space G=(H,O,Δ) and the
corresponding generalized weight of evidence wG, we can define
*upper* and *lower* weights of evidence, determined by the
maximum and minimum values in the range, somewhat analogous to the
notions of upper and lower probability.
Define the *upper weight of evidence function* ¯¯¯¯wG by taking
| | | |
| --- | --- | --- |
| | ¯¯¯¯wG(ob,h)=sup{w(ob,h)∣w∈wG}. | |
Similarly, define the *lower weight of evidence function*
w––G by taking
| | | |
| --- | --- | --- |
| | w––G(ob,h)=inf{w(ob,h)∣w∈wG}. | |
These upper and lower weights of evidence can be used to compute the
bounds on the posteriors obtained by updating a prior probability via
the generalized weight of evidence of an observation, in the case
where G is uncorrelated, and when there are two hypotheses.
###### Proposition 3.5
Let G=(H,O,Δ) be an uncorrelated generalized evidence
space.
1. The following inequalities hold when the denominators are
nonzero:
| | | | | |
| --- | --- | --- | --- | --- |
| | (Pμ0,ob)∗(h) | ≤¯¯¯¯wG(ob,h)μ0(h)¯¯¯¯wG(ob,h)μ0(h)+∑h′≠hw––G(ob,h′)μ0(h′); | | (5) |
| | (Pμ0,ob)∗(h) | ≥w––G(ob,h)μ0(h)w––G(ob,h)μ0(h)+∑h′≠h¯¯¯¯wG(ob,h′)μ0(h′). | | (6) |
If |H|=2, these inequalities can be taken to be equalities.
2. The following equalities hold:
| | | | |
| --- | --- | --- | --- |
| | ¯¯¯¯wG(ob,h) | =(Ph)∗(ob)(Ph)∗(ob)+∑h′≠h(Ph′)∗(ob); | |
| | w––G(ob,h) | =(Ph)∗(ob)(Ph)∗(ob)+∑h′≠h(Ph′)∗(ob), | |
where Ph={μ(h)∣μ∈Δ}, for all h∈H.
Thus, if have an uncorrelated generalized evidence space with two
hypotheses, we can compute the bounds on the posteriors
Pμ0,ob
in terms of upper and lower weights of evidence
using Proposition [3.5](#S3.Thmtheorem5 "Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")(a), which consists
of equalities in that case.
Moreover, we can compute the upper and lower weights of evidence
using Proposition [3.5](#S3.Thmtheorem5 "Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")(b).
As we now show, the inequalities in
Proposition [3.5](#S3.Thmtheorem5 "Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")(a) can be strict if there are more
than two hypotheses.
###### Example 3.6
Let H={D,E,F} and O={X,Y}, and
consider the two probability measures μ1 and μ2, where
μ1(X)=1/3 and
μ2(X)=2/3. Let G=(H,O,Δ), where
Δ={μ∣μ(h)∈{μ1,μ2}}. Clearly, Δ is
uncorrelated. Let μ0 be the uniform prior on H, so that
μ0(D)=μ0(E)=μ0(F)=1/3. Using Proposition [3.5](#S3.Thmtheorem5 "Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")(b),
we can compute that the upper and lower weights of evidence are as given
in the following tables:
| ¯¯¯¯wG | D | E | F |
| --- | --- | --- | --- |
| X | 1/2 | 1/2 | 1/2 |
| Y | 1/2 | 1/2 | 1/2 |
| w––G | D | E | F |
| --- | --- | --- | --- |
| X | 1/5 | 1/5 | 1/5 |
| Y | 1/5 | 1/5 | 1/5 |
The uniform measure is the identity for ⊕, and therefore
μ0⊕w(ob,⋅)=w(ob,⋅). It follows that
Pμ0,X={w(X,⋅)∣w∈wG}. Hence,
(Pμ0,X)∗(D)=1/2 and
(Pμ0,X)∗(D)=1/5. But the right-hand sides of
([5](#S3.E5 "(5) ‣ item (a) ‣ Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")) and ([6](#S3.E6 "(6) ‣ item (a) ‣ Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")) are 5/9 and 1/6,
respectively, and similarly for hypotheses E and F. Thus, in this
case, the inequalities in Proposition [3.5](#S3.Thmtheorem5 "Proposition 3.5 ‣ 3 Evidence with Uncertain Likelihoods ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.")(a) are strict.
While uncorrelated generalized evidence spaces are certainly of
interest, correlated spaces arise in natural settings. To see this,
first consider the following somewhat contrived example.
###### Example 3.7
Consider the following variant of Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."). Alice has two
coins, one that is double-headed and one that is biased 3/4 towards
heads, and chooses which one to give Zoe. Bob also has two coins,
one that is fair and one that is biased 2/3 towards tails, and
chooses which one to give Zoe. Zoe chooses one of the two coins she
was given and tosses it. The hypotheses are {A,B} and the
observations are {heads,tails}, as in Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."). The
likelihood function μ1 for Alice’s double-headed coin is given by
μ1(heads)=1, while the likelihood function μ2 for Alice’s biased
coin is given by μ2(heads)=3/4. Similarly, the likelihood function
μ3 for Bob’s fair coin is given by μ3(heads)=1/2, and the
likelihood function μ4 for Bob’s biased coin is given by
μ4(heads)=1/3.
If Alice and Bob each make their choice of which coin to
give Zoe independently,
we can use the following
generalized evidence space to model the situation:
| | | |
| --- | --- | --- |
| | G1=({A,B},{heads,tails},Δ1), | |
where
| | | |
| --- | --- | --- |
| | Δ1={(μ1,μ3),(μ1,μ4),(μ2,μ3),(μ2,μ4)}. | |
Clearly, Δ1 is uncorrelated, since it is equal to
{μ1,μ2}×{μ3,μ4}.
On the other hand, suppose that Alice and Bob agree beforehand
that either Alice gives Zoe her double-headed coin and Bob gives Zoe
his fair coin, or Alice gives Zoe her biased coin and Bob gives Zoe
his biased coin.
This situation can be modeled using the following generalized evidence
space:
| | | |
| --- | --- | --- |
| | G2=({A,B},{heads,tails},Δ2), | |
where
| | | |
| --- | --- | --- |
| | Δ2={(μ1,μ3),(μ2,μ4)}. | |
Here, note that Δ2 is a correlated set of likelihood
mappings.
While this example is artificial,
the example in the introduction, where the robot’s sensors could have
come from either factory 1 or factory 2, is a perhaps more realistic
case where correlated evidence spaces arise. The key point here is
that these examples
show that we need to go beyond just refining hypotheses to capture a
situation.
4 Combining Evidence
---------------------
An important property of Shafer’s \citeyearr:shafer82 representation of
evidence is that it is possible to combine the weight of evidence of
independent observations to obtain the weight of evidence of a
sequence of observations. The purpose of this section is to show that
our framework enjoys a similar property, but, rather unsurprisingly,
new subtleties arise due to the presence of uncertainty. For
simplicity, in this section we concentrate exclusively on combining
the evidence of a sequence of two observations; the general
case follows in a straightforward way.
Recall how combining evidence is handled in Shafer’s approach. Let
E=(H,O,μ) be an evidence space.
We define the likelihood functions μh
on pairs of observations, by taking
μh(⟨ob1,ob2⟩)=μh(ob1)μh(ob2). In other words, the
probability of observing a particular sequence of observations given
h is the product of the probability of making each observation in
the sequence.
Thus, we are implicitly assuming that the observations are independent.
It is well known (see, for example,
[[Halpern and FaginHalpern and
Fagin1992](#bib.bibx4), Theorem 4.3]) that Dempster’s Rule of Combination can be
used to combine evidence; that is,
| | | |
| --- | --- | --- |
| | wE(⟨ob1,ob2⟩,⋅)=wE(ob1,⋅)⊕wE(ob2,⋅). | |
If we let μ0 be a prior probability on the hypotheses, and
μ⟨ob1,ob2⟩ be the probability on the hypotheses
after observing ob1 and ob2, we can verify that
| | | |
| --- | --- | --- |
| | μ⟨ob1,ob2⟩=μ0⊕wE(⟨ob1,ob2⟩,⋅). | |
Here we are assuming that exactly one hypothesis holds, and it holds
each time we make an observation. That is, if Zoe picks the
double-headed coin, she uses it for both coin tosses.
###### Example 4.1
Recall Example [2.1](#S2.Thmtheorem1 "Example 2.1 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), where
Alice just has a double-headed coin and Bob just has a fair coin.
Suppose that Zoe, after being given the coins and choosing one of them,
tosses it twice, and it lands heads both times.
It is straightforward to compute that
| wE | A | B |
| --- | --- | --- |
| ⟨heads,heads⟩ | 4/5 | 1/5 |
| ⟨heads,tails⟩ | 0 | 1 |
| ⟨tails,heads⟩ | 0 | 1 |
| ⟨tails,tails⟩ | 0 | 1 |
Not surprisingly, if either of the observations is tails, the coin
cannot be Alice’s. In the case where the observations are
⟨heads,heads⟩, the evidence for the coin being Alice’s (that is,
double-headed) is greater than if a single heads is observed, since
from Example [2.1](#S2.Thmtheorem1 "Example 2.1 ‣ 2 Evidence: A Review ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University."), wE(heads,A)=2/3. This agrees
with our intuition that seeing two heads in a row provides more
evidence for a coin to be double-headed than if a single heads is
observed.
How should we combine evidence for a sequence of observations when we
have a generalized evidence space?
That depends on how we interpret the assumption that the “same”
hypothesis holds for each observation.
In a generalized evidence space, we have possibly many likelihood
functions for each hypothesis.
The real issue is whether we use the same likelihood function each time
we evaluate an observation, or whether we can use a different likelihood
function associated with that hypothesis. The following examples show
that this distinction can be critical.
###### Example 4.2
Consider Example [1.2](#S1.Thmtheorem2 "Example 1.2 ‣ 1 Introduction ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") again, where Alice has two coins (one
double-headed, one biased toward heads), and Bob has a fair
coin. Alice chooses a coin and gives it to Zoe; Bob gives his coin to
Zoe.
As we observed, there are two likelihood mappings in this case, giving
rise to the weights of evidence
we called w1 and w2; w1 corresponds to Alice’s coin being
double-headed, and w2 corresponds to the coin being biased 3/4
towards heads.
Suppose that Zoe tosses the coin twice.
Since she is tossing the same coin, it seems most appropriate to consider
the generalized weight of evidence
| | | |
| --- | --- | --- |
| | {w′∣w′(⟨ob1,ob2⟩,⋅)=wi(ob1,⋅)⊕wi(ob2,⋅),i∈{1,2}}. | |
On the other hand, suppose Zoe
first chooses whether she will always use Alice’s or Bob’s coin.
If she chooses Bob, then she obviously uses his coin for both tosses.
If she chooses Alice, before each toss, she asks Alice for a
coin and tosses it; however, she does not have to use the same coin of
Alice’s for each toss.
Now the likelihood
function
associated with each observation can change.
Thus, the appropriate generalized weight of evidence is
| | | |
| --- | --- | --- |
| | {w′∣w′(⟨ob1,ob2⟩,⋅)=wi(ob1,⋅)⊕wj(ob2,⋅),i,j∈{1,2}}. | |
Fundamentally, combining evidence in generalized evidence spaces
relies on Dempster’s rule of combination, just like in Shafer’s
approach. However, as Example [4.2](#S4.Thmtheorem2 "Example 4.2 ‣ 4 Combining Evidence ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") shows, the exact details
depends on our understanding of the experiment. While the first
approach used in Example [4.2](#S4.Thmtheorem2 "Example 4.2 ‣ 4 Combining Evidence ‣ Evidence with Uncertain Likelihoods A preliminary version of this paper appeared in the Proceedings of the 21st Conference on Uncertainty in Artificial Intelligence, pp. 243–250, 2005. Most of this work was done while the second author was at Cornell University.") seems more appropriate in
most cases that we could think of, we suspect that there will be cases
where something like the second approach may be appropriate.
5 Conclusion
-------------
In the literature on evidence, it is generally assumed that there is a
single likelihood function associated with each hypothesis. There are
natural examples, however, which violate this assumption. While it may
appear that a simple step of refining the set of hypotheses allows us
to use standard techniques, we have shown that this approach can lead
to counterintuitive results when evidence is used as a basis for
making decisions. To solve this problem, we proposed a generalization
of a popular approach to representing evidence. This generalization
behaves correctly under updating, and gives the same bounds on the
posterior probability as that obtained by refining the set of hypotheses
when there is no correlation between the various
likelihood functions for the
hypotheses. As we show, this is the one situation where we can identify
a generalized evidence space with the space obtained by refining the
hypotheses.
One advantage of our approach is that we can also reason about
situations where the
likelihood functions are correlated, something that cannot be done by
refining the set of hypotheses.
We have also looked at how to combine evidence in a generalized
evidence space. While the basic ideas from standard evidence spaces
carry over, that is, the combination is essentially obtained using
Dempster’s rule of combination, the exact details of how this
combination should be performed depend on the specifics of how the
likelihood functions change for each observation. A more detailed
dynamic model
would be helpful in understanding the combination of evidence in a
generalized evidence space setting; we leave this exploration for
future work.
### Acknowledgments
Work supported in part by NSF under grants
CTC-0208535 and ITR-0325453, by ONR under grant N00014-02-1-0455,
by the DoD Multidisciplinary University Research
Initiative (MURI) program administered by the ONR under
grants N00014-01-1-0795 and N00014-04-1-0725, and by AFOSR under grant
F49620-02-1-0101.
The second author was also supported in part by
AFOSR grants F49620-00-1-0198 and
F49620-03-1-0156, National Science Foundation Grants 9703470 and
0430161, and ONR Grant N00014-01-1-0968. |
b8c9276a-04da-40a8-aa43-b5aafbc44730 | trentmkelly/LessWrong-43k | LessWrong | [Job Ad] MATS is hiring!
If you are interested in supporting the development of research projects and researchers in AI safety, the MATS team is currently hiring for Community Manager, Research Manager, and Operations Generalist roles and would love to hear from you. Please apply by Nov 3 to join our team for the Winter 2024-25 Program over the period of Dec 9-Apr 11. Most open roles have the possibility of long-term extension depending on performance and program needs.
Introduction
The ML Alignment & Theory Scholars (MATS) program aims to find and train talented individuals for what we see as the world’s most urgent and talent-constrained problem: reducing risks from unaligned artificial intelligence. We believe that ambitious young researchers from a variety of backgrounds have the potential to contribute to the field of alignment research. We aim to provide the mentorship, curriculum, financial support, and community necessary to aid this transition. Please see our theory of change and website for more details.
We are generally looking for candidates who:
* Are excited to work in a fast-paced environment and are comfortable switching responsibilities and projects as the needs of MATS change;
* Want to help the team with high-level strategy;
* Are self-motivated and can take on new responsibilities within MATS over time and;
* Care about what is best for the long-term future, independent of MATS’ interests.
Please apply via this form.
Community Manager
We are expanding the MATS Community Health Team and are looking for an individual with strong interpersonal skills who will work with the Community Management Lead and the rest of the MATS team to support the needs of scholars and improve the MATS community. Ideal candidates are excited about AI safety field-building and enjoy supporting others.
Responsibilities
A Community Manager needs to be proactive and responsive to MATS scholars’ needs and able to enhance scholar experience through personal conversations, mediation, eve |
2f62759b-c6a6-4d1a-ad7f-45bf6e2abfec | trentmkelly/LessWrong-43k | LessWrong | DIY LessWrong Jewelry
[There are no affiliate links in this post and I haven't been paid by anyone; I just happened to have bought the charms from Shein. You can probably get similar things on Temu, Aliexpress or Amazon]
I made a cute LessWrong themed necklace/earring set for cheap, here's how.
For the necklace, buy a pair of these earrings from Shein:
US: https://us.shein.com/1pair-Fashionable-Rhinestone-Star-Decor-Drop-Earrings-For-Women-For-Daily-Decoration-p-15276285.html
CAN: https://ca.shein.com/1pair-Fashionable-Rhinestone-Star-Decor-Drop-Earrings-For-Women-For-Daily-Decoration-p-15276285.html.
Then remove the dangly charm and use a wire to attach it to a necklace chain.
(I bought a cheap necklace from Shein to use as the chain but it tarnished within days. Amazon seems to sell decent chains/necklaces for ~20$, but I haven't bought any so can't personally recommend them (I used an old chain from my grandmother instead). If you're buying a necklace make sure any pre-existing charms can be removed.
You can either get two pairs of the above earrings to make a set, or get these ones if you prefer studs:
US: https://us.shein.com/1pair-S999-Sterling-Silver-Cubic-Zirconia-Eight-pointed-Star-Design-Symmetric-Earrings-For-Women-p-23036383.html
CAN: https://ca.shein.com/1pair-S999-Sterling-Silver-Cubic-Zirconia-Eight-pointed-Star-Design-Symmetric-Earrings-For-Women-p-23036383.html
Here they all are together:
Note the stud is quite small. Here is what it looks like on my ear, in comparison with the hoop earrings: |
6d03cb65-da5c-41a9-be01-b956823edacc | trentmkelly/LessWrong-43k | LessWrong | Niche product design
I came to realize that the most inspiring, authentic design on the internet today comes from niche places.
As a designer, I’ve been following the herd for quite some time, as I used to observe the big-corps as role models. Whether I had to design a simple UI element, a marketing website, or search for inspiration—I've always returned to the same old and familiar places. Big Tech, best practices, pattern galleries. You know—the us(ual).
Popular products of tech giants we all know not only dominate the web, but they also stand as a dogma in the field of product design, serving as trendsetters.
Indeed tech has shaped our lives for a long time now. In the context of design, it played a significant role in forming the product design community as we know it today. The once-small community has grown into a genuine discipline: the importance of design has increased, designers are given a mandate in organizations, and we even got our title battles.
We should have reached our destination by now.
But once a culture matures, it starts to develop its bad habits. Throughout the years, some voices have criticized1 the state of the design community, claiming that it has lost its creativity: designers aim for eyeballs, and websites have become too predictable.
I share the feeling that our design tools, aesthetics, and communities have hit a plateau. The golden age of product design has faded, ushering in an era of boredom:
> "The world of apps – once an exciting canvas for creative exploration – has become repetitive, predictable and… boring."
>
> Andy Allen, No more boring apps
Standardization isn’t exclusive to the design industry. It’s an inevitable outcome in any emerging field combined with a technology seeking for a purpose.
When was the last time we got excited about a new smartphone?
When a new field emerges, experiments and ideas flourish. Innovation is at its best. But then it becomes dense, saturated with many of the same. Guidelines are being written, and conv |
d8980e93-5c80-476d-8c8a-dbe7d59c0f84 | trentmkelly/LessWrong-43k | LessWrong | Thoughts on hacking aromanticism?
Several years ago, Alicorn wrote an article about how she hacked herself to be polyamorous. I'm interested in methods for hacking myself to be aromantic. I've had some success with this, so I'll share what's worked for me, but I'm really hoping you all will chime in with your ideas in the comments.
MOTIVATION
Why would someone want to be aromantic? There's the obvious time commitment involved in romance, which can be considerable. This is an especially large drain if you're in a situation where finding suitable partners is difficult, which means most of this time is spent enduring disappointment (e.g. if you're heterosexual and the balance of singles in your community is unfavorable).
But I think an even better way to motivate aromanticism is by referring you to this Paul Graham essay, The Top Idea in Your Mind. To be effective at accomplishing your goals, you'd like to have your goals be the most interesting thing you have to think about. I find it's far too easy for my love life to become the most interesting thing I have to think about, for obvious reasons.
SUBPROBLEMS
After thinking some, I came up with a list of 4 goals people try to achieve through engaging in romance:
1. Companionship.
2. Sexual pleasure.
3. Infatuation (also known as new relationship energy).
4. Validation. This one is trickier than the previous three, but I think it's arguably the most important. Many unhappy singles have friends they are close to, and know how to masturbate, but they still feel lousy in a way people in post-infatuation relationships do not. What's going on? I think it's best described as a sort of romantic insecurity. To test this out, imagine a time when someone you were interested in was smiling at you, and contrast that with the feeling of someone you were interested in turning you down. You don't have to experience companionship or sexual pleasure from these interactions for them to have a major impact on your "romantic self-esteem". And in a cul |
2ed6b30a-1685-48f5-9892-f4b78aa3f3ad | trentmkelly/LessWrong-43k | LessWrong | [SEQ RERUN] Neural Categories
Today's post, Neural Categories was originally published on 10 February 2008. A summary (taken from the LW wiki):
> You treat intuitively perceived hierarchical categories like the only correct way to parse the world, without realizing that other forms of statistical inference are possible even though your brain doesn't use them. It's much easier for a human to notice whether an object is a "blegg" or "rube"; than for a human to notice that red objects never glow in the dark, but red furred objects have all the other characteristics of bleggs. Other statistical algorithms work differently.
Discuss the post here (rather than in the comments to the original post).
This post is part of the Rerunning the Sequences series, where we'll be going through Eliezer Yudkowsky's old posts in order so that people who are interested can (re-)read and discuss them. The previous post was Disguised Queries, and you can use the sequence_reruns tag or rss feed to follow the rest of the series.
Sequence reruns are a community-driven effort. You can participate by re-reading the sequence post, discussing it here, posting the next day's sequence reruns post, or summarizing forthcoming articles on the wiki. Go here for more details, or to have meta discussions about the Rerunning the Sequences series. |
cec7993f-ce5b-41cb-a73a-41c18c90eb7d | StampyAI/alignment-research-dataset/alignmentforum | Alignment Forum | A stylized dialogue on John Wentworth's claims about markets and optimization
(*This is a stylized version of a real conversation, where the first part happened as part of a public debate between John Wentworth and Eliezer Yudkowsky, and the second part happened between John and me over the following morning. The below is combined, stylized, and written in my own voice throughout. The specific concrete examples in John's part of the dialog were produced by me. It's over a year old. Sorry for the lag.*)
*(As to whether John agrees with this dialog, he said "there was not any point at which I thought my views were importantly misrepresented" when I asked him for comment.)*
**J:** It seems to me that the field of alignment doesn't understand the most basic theory of agents, and is missing obvious insights when it comes to modeling the sorts of systems they purport to study.
**N:** Do tell. (I'm personally [sympathetic](https://www.lesswrong.com/posts/Zp6wG5eQFLGWwcG6j/focus-on-the-places-where-you-feel-shocked-everyone-s) to claims of the form "none of you idiots have any idea wtf you're doing", and am quite open to the hypothesis that I've been an idiot in this regard.)
**J:** Consider the coherence theorems that say that if you can't pump resources out of a system, then it's acting agent-like.
**N:** I'd qualify "agent-like with respect to you", if I used the word 'agent' at all (which I mostly wouldn't), and would caveat that there are a few additional subtleties, but sure.
**J:** Some of those subtleties are important! In particular: there's a gap between systems that you can't pump resources out of, and systems that have a utility function. The bridge across that gap is an additional assumption that the system won't pass up certain gains (in a specific sense).
Roughly: if you won't accept 1 pepper for 1 mushroom, then you should accept 2 mushrooms for 1 pepper, because a system that accepts both of those trades winds up with strictly more resources than a system that rejects both (by 1 mushroom), and you should be able to do at least that well.
**N:** I agree.
**J:** But some of the epistemically efficient systems around us violate this property.
For instance, consider a market for (at least) two goods: peppers and mushrooms; with (at least) two participants: Alice and Bob. Suppose Alice's utility is UA(p,m):=log10(p)+log100(m).mjx-chtml {display: inline-block; line-height: 0; text-indent: 0; text-align: left; text-transform: none; font-style: normal; font-weight: normal; font-size: 100%; font-size-adjust: none; letter-spacing: normal; word-wrap: normal; word-spacing: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; margin: 0; padding: 1px 0}
.MJXc-display {display: block; text-align: center; margin: 1em 0; padding: 0}
.mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex] {display: inline-table}
.mjx-full-width {text-align: center; display: table-cell!important; width: 10000em}
.mjx-math {display: inline-block; border-collapse: separate; border-spacing: 0}
.mjx-math \* {display: inline-block; -webkit-box-sizing: content-box!important; -moz-box-sizing: content-box!important; box-sizing: content-box!important; text-align: left}
.mjx-numerator {display: block; text-align: center}
.mjx-denominator {display: block; text-align: center}
.MJXc-stacked {height: 0; position: relative}
.MJXc-stacked > \* {position: absolute}
.MJXc-bevelled > \* {display: inline-block}
.mjx-stack {display: inline-block}
.mjx-op {display: block}
.mjx-under {display: table-cell}
.mjx-over {display: block}
.mjx-over > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-under > \* {padding-left: 0px!important; padding-right: 0px!important}
.mjx-stack > .mjx-sup {display: block}
.mjx-stack > .mjx-sub {display: block}
.mjx-prestack > .mjx-presup {display: block}
.mjx-prestack > .mjx-presub {display: block}
.mjx-delim-h > .mjx-char {display: inline-block}
.mjx-surd {vertical-align: top}
.mjx-surd + .mjx-box {display: inline-flex}
.mjx-mphantom \* {visibility: hidden}
.mjx-merror {background-color: #FFFF88; color: #CC0000; border: 1px solid #CC0000; padding: 2px 3px; font-style: normal; font-size: 90%}
.mjx-annotation-xml {line-height: normal}
.mjx-menclose > svg {fill: none; stroke: currentColor; overflow: visible}
.mjx-mtr {display: table-row}
.mjx-mlabeledtr {display: table-row}
.mjx-mtd {display: table-cell; text-align: center}
.mjx-label {display: table-row}
.mjx-box {display: inline-block}
.mjx-block {display: block}
.mjx-span {display: inline}
.mjx-char {display: block; white-space: pre}
.mjx-itable {display: inline-table; width: auto}
.mjx-row {display: table-row}
.mjx-cell {display: table-cell}
.mjx-table {display: table; width: 100%}
.mjx-line {display: block; height: 0}
.mjx-strut {width: 0; padding-top: 1em}
.mjx-vsize {width: 0}
.MJXc-space1 {margin-left: .167em}
.MJXc-space2 {margin-left: .222em}
.MJXc-space3 {margin-left: .278em}
.mjx-test.mjx-test-display {display: table!important}
.mjx-test.mjx-test-inline {display: inline!important; margin-right: -1px}
.mjx-test.mjx-test-default {display: block!important; clear: both}
.mjx-ex-box {display: inline-block!important; position: absolute; overflow: hidden; min-height: 0; max-height: none; padding: 0; border: 0; margin: 0; width: 1px; height: 60ex}
.mjx-test-inline .mjx-left-box {display: inline-block; width: 0; float: left}
.mjx-test-inline .mjx-right-box {display: inline-block; width: 0; float: right}
.mjx-test-display .mjx-right-box {display: table-cell!important; width: 10000em!important; min-width: 0; max-width: none; padding: 0; border: 0; margin: 0}
.MJXc-TeX-unknown-R {font-family: monospace; font-style: normal; font-weight: normal}
.MJXc-TeX-unknown-I {font-family: monospace; font-style: italic; font-weight: normal}
.MJXc-TeX-unknown-B {font-family: monospace; font-style: normal; font-weight: bold}
.MJXc-TeX-unknown-BI {font-family: monospace; font-style: italic; font-weight: bold}
.MJXc-TeX-ams-R {font-family: MJXc-TeX-ams-R,MJXc-TeX-ams-Rw}
.MJXc-TeX-cal-B {font-family: MJXc-TeX-cal-B,MJXc-TeX-cal-Bx,MJXc-TeX-cal-Bw}
.MJXc-TeX-frak-R {font-family: MJXc-TeX-frak-R,MJXc-TeX-frak-Rw}
.MJXc-TeX-frak-B {font-family: MJXc-TeX-frak-B,MJXc-TeX-frak-Bx,MJXc-TeX-frak-Bw}
.MJXc-TeX-math-BI {font-family: MJXc-TeX-math-BI,MJXc-TeX-math-BIx,MJXc-TeX-math-BIw}
.MJXc-TeX-sans-R {font-family: MJXc-TeX-sans-R,MJXc-TeX-sans-Rw}
.MJXc-TeX-sans-B {font-family: MJXc-TeX-sans-B,MJXc-TeX-sans-Bx,MJXc-TeX-sans-Bw}
.MJXc-TeX-sans-I {font-family: MJXc-TeX-sans-I,MJXc-TeX-sans-Ix,MJXc-TeX-sans-Iw}
.MJXc-TeX-script-R {font-family: MJXc-TeX-script-R,MJXc-TeX-script-Rw}
.MJXc-TeX-type-R {font-family: MJXc-TeX-type-R,MJXc-TeX-type-Rw}
.MJXc-TeX-cal-R {font-family: MJXc-TeX-cal-R,MJXc-TeX-cal-Rw}
.MJXc-TeX-main-B {font-family: MJXc-TeX-main-B,MJXc-TeX-main-Bx,MJXc-TeX-main-Bw}
.MJXc-TeX-main-I {font-family: MJXc-TeX-main-I,MJXc-TeX-main-Ix,MJXc-TeX-main-Iw}
.MJXc-TeX-main-R {font-family: MJXc-TeX-main-R,MJXc-TeX-main-Rw}
.MJXc-TeX-math-I {font-family: MJXc-TeX-math-I,MJXc-TeX-math-Ix,MJXc-TeX-math-Iw}
.MJXc-TeX-size1-R {font-family: MJXc-TeX-size1-R,MJXc-TeX-size1-Rw}
.MJXc-TeX-size2-R {font-family: MJXc-TeX-size2-R,MJXc-TeX-size2-Rw}
.MJXc-TeX-size3-R {font-family: MJXc-TeX-size3-R,MJXc-TeX-size3-Rw}
.MJXc-TeX-size4-R {font-family: MJXc-TeX-size4-R,MJXc-TeX-size4-Rw}
.MJXc-TeX-vec-R {font-family: MJXc-TeX-vec-R,MJXc-TeX-vec-Rw}
.MJXc-TeX-vec-B {font-family: MJXc-TeX-vec-B,MJXc-TeX-vec-Bx,MJXc-TeX-vec-Bw}
@font-face {font-family: MJXc-TeX-ams-R; src: local('MathJax\_AMS'), local('MathJax\_AMS-Regular')}
@font-face {font-family: MJXc-TeX-ams-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_AMS-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_AMS-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_AMS-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-B; src: local('MathJax\_Caligraphic Bold'), local('MathJax\_Caligraphic-Bold')}
@font-face {font-family: MJXc-TeX-cal-Bx; src: local('MathJax\_Caligraphic'); font-weight: bold}
@font-face {font-family: MJXc-TeX-cal-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-R; src: local('MathJax\_Fraktur'), local('MathJax\_Fraktur-Regular')}
@font-face {font-family: MJXc-TeX-frak-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-B; src: local('MathJax\_Fraktur Bold'), local('MathJax\_Fraktur-Bold')}
@font-face {font-family: MJXc-TeX-frak-Bx; src: local('MathJax\_Fraktur'); font-weight: bold}
@font-face {font-family: MJXc-TeX-frak-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Fraktur-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Fraktur-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Fraktur-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-BI; src: local('MathJax\_Math BoldItalic'), local('MathJax\_Math-BoldItalic')}
@font-face {font-family: MJXc-TeX-math-BIx; src: local('MathJax\_Math'); font-weight: bold; font-style: italic}
@font-face {font-family: MJXc-TeX-math-BIw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-BoldItalic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-BoldItalic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-BoldItalic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-R; src: local('MathJax\_SansSerif'), local('MathJax\_SansSerif-Regular')}
@font-face {font-family: MJXc-TeX-sans-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-B; src: local('MathJax\_SansSerif Bold'), local('MathJax\_SansSerif-Bold')}
@font-face {font-family: MJXc-TeX-sans-Bx; src: local('MathJax\_SansSerif'); font-weight: bold}
@font-face {font-family: MJXc-TeX-sans-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-I; src: local('MathJax\_SansSerif Italic'), local('MathJax\_SansSerif-Italic')}
@font-face {font-family: MJXc-TeX-sans-Ix; src: local('MathJax\_SansSerif'); font-style: italic}
@font-face {font-family: MJXc-TeX-sans-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_SansSerif-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_SansSerif-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_SansSerif-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-script-R; src: local('MathJax\_Script'), local('MathJax\_Script-Regular')}
@font-face {font-family: MJXc-TeX-script-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Script-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Script-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Script-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-type-R; src: local('MathJax\_Typewriter'), local('MathJax\_Typewriter-Regular')}
@font-face {font-family: MJXc-TeX-type-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Typewriter-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Typewriter-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Typewriter-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-R; src: local('MathJax\_Caligraphic'), local('MathJax\_Caligraphic-Regular')}
@font-face {font-family: MJXc-TeX-cal-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Caligraphic-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Caligraphic-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Caligraphic-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-B; src: local('MathJax\_Main Bold'), local('MathJax\_Main-Bold')}
@font-face {font-family: MJXc-TeX-main-Bx; src: local('MathJax\_Main'); font-weight: bold}
@font-face {font-family: MJXc-TeX-main-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-I; src: local('MathJax\_Main Italic'), local('MathJax\_Main-Italic')}
@font-face {font-family: MJXc-TeX-main-Ix; src: local('MathJax\_Main'); font-style: italic}
@font-face {font-family: MJXc-TeX-main-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-R; src: local('MathJax\_Main'), local('MathJax\_Main-Regular')}
@font-face {font-family: MJXc-TeX-main-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Main-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Main-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Main-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-I; src: local('MathJax\_Math Italic'), local('MathJax\_Math-Italic')}
@font-face {font-family: MJXc-TeX-math-Ix; src: local('MathJax\_Math'); font-style: italic}
@font-face {font-family: MJXc-TeX-math-Iw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Math-Italic.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Math-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Math-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size1-R; src: local('MathJax\_Size1'), local('MathJax\_Size1-Regular')}
@font-face {font-family: MJXc-TeX-size1-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size1-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size1-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size1-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size2-R; src: local('MathJax\_Size2'), local('MathJax\_Size2-Regular')}
@font-face {font-family: MJXc-TeX-size2-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size2-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size2-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size2-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size3-R; src: local('MathJax\_Size3'), local('MathJax\_Size3-Regular')}
@font-face {font-family: MJXc-TeX-size3-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size3-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size3-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size3-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size4-R; src: local('MathJax\_Size4'), local('MathJax\_Size4-Regular')}
@font-face {font-family: MJXc-TeX-size4-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Size4-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Size4-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Size4-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-R; src: local('MathJax\_Vector'), local('MathJax\_Vector-Regular')}
@font-face {font-family: MJXc-TeX-vec-Rw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Regular.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-B; src: local('MathJax\_Vector Bold'), local('MathJax\_Vector-Bold')}
@font-face {font-family: MJXc-TeX-vec-Bx; src: local('MathJax\_Vector'); font-weight: bold}
@font-face {font-family: MJXc-TeX-vec-Bw; src /\*1\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax\_Vector-Bold.eot'); src /\*2\*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax\_Vector-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax\_Vector-Bold.otf') format('opentype')}
(where p and m are the quantities of peppers and mushrooms owned by Alice, respectively), and Bob's utility is UB(p,m):=log100(p)+log10(m) (where p and m are the quantities of peppers and mushrooms owned by Bob, respectively).
Example equilibrium: the price is 3 peppers for 1 mushroom. Alice doesn't trade at this price when she has 3log′10(p)=1log′100(m), i.e. 3ln(10)/p=1ln(100)/m, i.e. 3/p=2/m (using the fact that ln(100)=ln(102)=2ln(10)), i.e. when Alice has 1.5 times as many peppers as she has mushrooms. Bob doesn't trade at this price when he has 6 times as many peppers as mushrooms, by a similar argument. So these prices can be an equilibrium whenever Alice has 1.5x as many peppers as mushrooms, and Bob has 6x as many peppers as mushrooms (regardless of the absolute quantities).
Now consider offering the market a trade of 25,000 peppers for 10,000 mushrooms. If Alice has 20,000 mushrooms (and thus 30,000 peppers), and Bob has only 1 mushroom (and thus 6 peppers), then the trade is essentially up to Alice. She'd observe that
log10(55,000)+log100(10,000)>log10(30,000)+log100(20,000),so she (and thus, the market as a whole) would accept. But if Bob had 20,000 mushrooms (and thus 120,000 peppers), and Alice had only 2 mushrooms (and thus 3 peppers), then the trade is essentially up to Bob. He'd observe
log100(145,000)+log10(10,000)<log100(120,000)+log10(20,000),so he wouldn't take the trade.[[1]](#fn5rqvtoi40rw)
Thus, we can see that whether a market — considered altogether — takes a trade, depends not only on the prices in the market (which you might have thought of as a sort of epistemic state, and that you might have noted was epistemically efficient with respect to you), but also on the hidden internal state of the market.
**N:** Sure. The argument was never "every epistemically efficient (wrt you) system is an optimizer", but rather "sufficiently good optimizers are epistemically efficient (wrt you)".
**J:** You might be missing the point here. You can appeal to "you can't pump money out of the system" to get a type of *weak* efficiency, but you MIRI folk seem to think that "can't pump money out" arguments also imply a form of *strong* efficiency, that things like markets lack.
**N:** I agree that "you can't pump money out" does not suffice for a utility function, and that you need an additional "it doesn't pass up free money" constraint to bridge the gap. And I concede that I sometimes use "you can't pump money out of it" as a pointer to a larger cluster of criteria, and sometimes in a way that elides a real distinction, and sometimes because I haven't been tracking that distinction carefully in my own head.
...for the record, though, I expect AI systems that are capable of ending the acute risk period, to not pass up on free valuables. So I admit I'm not sure why you're focused on this distinction as important. Do you think we have a disagreement beyond the point about me sometimes playing fast-and-loose with coherence constraints?
**J:** I still suspect you're missing the point. In real life, systems that control valuable resources tend to have the property that you can't pump resources out of them, for the obvious competitive reason. But there's no similarly compelling reason for things to avoid having path-dependence in their preferences, as you'd find in a market.
**N:** Hold up. The obvious reason for optimizing systems to avoid path-dependent preferences is so that they avoid passing up certain gains. A property I expect a market made of sufficiently competent participants to possess.
**J:** In which case, we have a disagreement, yeah. Which... well, I proved my point a few paragraphs ago, and you seemed to agree? So I admit I'm confused by your position.
To refine my own position: aggregate systems of agents do not in general act like an agent. That's what I've been trying to say, here — the condition that you can expect lots of systems to possess in real life is a *weak* ("no money pump") efficiency property. The strong efficiency property ("takes certain gains") is much rarer, and is lost the moment you start aggregating agents.
(Indeed, once you notice that you shouldn't think of a market as an agent in the VNM sense, you're only one step away from the conclusion that you shouldn't think of the *constituent parts* as agents either. When you look closely, even the market participants are probably better modeled as weakly-efficient market-like systems rather than as agents.)
**N:** Woah, hold your horses there. Optimizing systems that are epistemically and instrumentally efficient wrt you (which I suppose I could suffer calling 'agents' in this context) totally aggregate into other agents.
**J:** ...have you failed to internalize my argument from above?
**N:** Nobody ever said that a collection of participants P each with preferences over a set G of goods, have to aggregate into an agent that also has preferences over G. The obvious guess is that that market aggregates into something more like an agent with preferences over functions from P to G, i.e., over different assignments of goods to each participant in the market.
Like, it's completely respectable for the market to value "Alice gains 25,000 peppers but loses 10,000 mushrooms" differently from "Bob gains 25,000 peppers but loses 10,000 mushrooms". It will look like it has a bunch of hidden state about who has which resources *when you consider only the resource totals*, but that's just an artifact of looking at the wrong outcome space.
(Aside: I have a better sense now of why I might want some sort of "epistemic efficiency implies instrumental efficiency" argument: intuitively, this seems like the sort of thing you might want when looking at optimizers that are themselves aggregates of smaller optimizers. Which is an update for me; thanks. More specifically, I was not tracking the way that markets should look instrumentally coherent, and my "epistemic efficiency isn't necessarily supposed to imply instrumental efficiency" argument now seems off-base.)
**J:** OK, yes, you can think of the market as having preferences over assignments of goods to participants, but then you still lose agency. For example, consider the trades (in that extended outcome space) "Alice loses 1 pepper, Bob gains 2 mushrooms", and the trade "Alice gains 3 peppers, Bob loses 2 mushrooms". The market won't take either of these trades, because Alice isn't willing to take the former, and Bob isn't willing to take the latter. And this is exactly an instance of an aggregate system that satisfies weak efficiency (it has no preference cycles / you can't pump money out of it), but violates strong efficiency (the order-dimension of its preference graph is not 1 / it passes up certain gains). Aggregates of agents aren't agents!
**N:** Oh, yeah, I flatly deny that.
**J:** It's... a theorem?
**N:** It might be a theorem in Earth!economics, about Earth!economics!rational agents who use broken decision theories. It's false in real life, and when aggregating agents smart enough to use better decision theories.
**J:** I'm not sure how you expect to swing that. Utility functions are defined only up to affine transformations, so you can't just say "do whatever leads to the higher aggregate utility". I don't see how you'd break the symmetry between different offers, while respecting the invariance of utility functions up to affine transformations.
**N:** Sure, I'm not saying you can figure out how to aggregate a bunch of agents into a superagent by looking at their utility functions alone! You need to take some other structure about the agents into account, such as information about what each agent thinks is fair.[[2]](#fnxcvz60f6b9e) (See, eg, the relevant [dath ilani papers](https://www.glowfic.com/replies/1729114#reply-1729114).)
**J:** Ah. Hmm.
**N:** To spell it out more precisely: what happens in real life is that Alice and Bob accept both trades, and then Alice gives Bob a pepper, and now they've achieved the certain gain of +1 pepper apiece. Or, more generally, they do something that is at least that good for both of them within the constraints of what they agree is fair — because why would either settle for a strategy that does worse than that? In real life, aggregate agents don't pass up certain gains of valuable resources, because they *value the resources*.
**J:** I... see.
**N:** ...
**J:** OK, well, note that this assumes that side-channel trades can occur, at prices other than the market prices.
**N:** Yeah. Side channels that the agents would fight to establish, so that they can *take advantage of certain gains*.
Although, of course, [logical decision theorists](https://arbital.com/p/logical_dt) don't *need* to be able to make side-trades to accept such bets, and they'll keep taking advantage of certain gains even if you forbid such trades. Like, if Alice and Bob have common knowledge that the market is either going to be offered the trade "Alice gains $1,000,000; Bob loses $1" or the trade "Alice loses $1; Bob gains $1,000,000", with equal probability of each, and they're not allowed to trade between themselves, then they can (and will, if they're smart) simply agree to accept whichever trade they're presented (because this joint strategy makes them both significantly richer in expectation).
Again, these are *smart folk* who *value resources*. You can argue all you want about how they shouldn't be able to get the extra money, but don't count on those arguments holding up.
Like, there's a basic mental technique here of asking "if the participants in the market were all *actually as smart as me* and *deeply driven to get more goods*, could they *somehow* find *some way* to *wind up richer*?" Argue as you may, the aggregate markets of dath ilan still won't pass up certain gains of valuable resources that *you* can easily point out.
**J:** This... is something of an update for me, I admit.
**N:** ...
**J:** Although, I note that, for all your high-falutin arguments about dath ilan, none of them are going to convince the pancreas and the thalamus to start making side-channel ATP trades, at price-analogs that differ from the equilibrium.
**N:** Indeed. It's no coincidence that artificial intelligence is an X-risk, and pancreases are not.
**J:** Ah, but the pancreas/thalamus interaction can tell us *something* about intelligence. As can the study of the energy market (of sorts) inside a bacterium. As can Earth's best financial markets, populated as they are by poorly-coordinated constituents who might not decide to use logical decision theory even if they knew they had the option. Agents might be normative, but *descriptively*, the world is full of systems that you merely can't pump money out of.
**N:** OK, sure. But that's a vastly weaker claim. I happily endorse the descriptive claim "lots of modern optimizers are even worse at taking certain gains, than they are at avoiding money-pumps."
(I don't see this as particularly relevant to alignment research, but I believe it.)
**J:** I see it as quite relevant to alignment research! I'm hoping to learn quite a bit from bacteria and markets, that generalizes to humans and artificial intelligences.
**N:** That sounds like a disagreement for another day. As for today, I'll settle for you retreating from the position that I'm lacking a basic understanding of the objects I wish to study, and from the position that intelligent agents don't aggregate into an agent (and, relatedly, from the position that 'markets' beat 'agents' as a model of capable optimizers).
**J:** I'll just point out again that, if you want to learn what human values are, you need a descriptive theory of humans rather than a normative theory of intelligence, and I still bet that weak-efficiency is a better descriptive model of most humans than agenthood.
1. **[^](#fnref5rqvtoi40rw)**This example (of two cases where a market's decision about a trade differs depending on hidden state) relies on the initial wealth distributions being unequal. Legends hold that there are other examples where the hidden state doesn't depend on initial differences, if the utilities aren't logarithmic. John Wentworth tells me he cares in practice about this additional fact, and notes that further information can be found in the literature under the heading of "non-existence of representative agents". I have not myself constructed such an example, and would be interested if someone has a simple one.
2. **[^](#fnrefxcvz60f6b9e)**Hopefully there are canonical solutions. For instance, in an ultimatum game, the Schelling fair point is that both participants get utility halfway between their best and worst deals, which solution is invariant under affine transformation. Knowing that agents are willing to accept these canonical solutions as 'fair' does not seem like a large additional burden of knowledge. |
2b420b42-f4d3-41f8-956d-90512874d39e | trentmkelly/LessWrong-43k | LessWrong | Help us seed AI Safety Brussels
crossposted on the EA forum: https://forum.effectivealtruism.org/posts/EwdgPJfeieCxe4cxa/help-us-seed-ai-safety-brussels
TLDR:
Brussels is a hotspot for AI policy and hosts several think tanks doing good work on AI safety. However, there is no established AI Safety group with paid staff that brings the community together or works on reaching out to students and professionals. For this reason, the European Network for AI Safety (ENAIS) and members from EA Belgium are teaming up to seed AI Safety Brussels.
This is a call for expressions of interest for potential collaborators to make this happen, with a wide range of ways to contribute, such as being a potential founder, policy/technical lead, volunteer, advisor, funder, etc. If you are interested in helping out in some capacity, please fill out this 2-minute form.
Potential priorities
I (Gergő) will caveat this by saying that the exact strategy (and name) of the organisation will be determined by the founding team and advisors. However, we think there are several potential pathways in which someone doing community building full or part-time could add a lot of value.
Running courses for professionals
The AIS community, as well as the EU AI Office, are bottlenecked by senior talent. Currently, there are only a few groups and organizations working to do outreach towards professionals.[1]
Brussels has a lot of senior people working on AIS. Understandably, they don't run courses to onboard others to AI Safety, as they are busy with object-level work. Conditional on seniority, if someone gets funded to start AIS Brussels, they could leverage the existing network and create an environment that is quite attractive for (policy) professionals to join, who are new to the field of AI Safety. By running courses similar to AI Safety Fundamentals by Bluedot, such a person (or team) could introduce AIS to hundreds of professionals per year and support them in their journey of upskilling and help them get into high-impact rol |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.