drocta

Karma: 79

drocta 10 Jan 2024 9:45 UTC
7 points
0
in reply to: mukashi’s comment on: Questions about Solomonoff induction
For example, it is not clear to me if once I consider a program that outputs 0101 I will simply ignore other programs that output that same thing plus one bit (e.g. 01010).
No, the thing about prefixes is about what strings encode a program, not about their outputs.
The purpose of this is mostly just to define a prior over possible programs, in a way that conveniently ensures that the total probability assigned over all programs is at most 1. Seeing as it still works for different choices of language, it probably doesn’t need to exactly use this kind of defining the probabilities, and I think any reasonable distribution over programs will do (at least, after enough observations)
But, while I think another distribution over programs should work, this thing with the prefix-free language is the standard way of doing it, and there are reasons it is nice.
The analogy for a normal programming language would be if no python script was a prefix of any other python script (which isn’t true of python scripts, but could be if they were required to end with some “end of program” string)
There will be many different programs which produce the exact same output when run, and will all be considered when doing Solomonoff induction.

The programs in A have 5 bits of Kolmogorov complexity each. The programs in B have 6 bits. The program C has 4
This may be pedantic of me, but I wouldn’t call the lengths of the programs, the Kolmogorov complexity of the program. The lengths of the programs are (upper bounds on) the Kolmogorov complexity of the outputs of the programs. The Kolmogorov complexity of a program g, would be the length of the shortest program which outputs the program g, not the length of g.
When you say that program C has 4 bits, is that just a value you picked, or are you obtaining that from somewhere?
Also, for a prefix-free programming language, you can’t have 2^5 valid programs of length 5, and 2^6 programs of length 6, because if all possible binary strings of length 5 were valid programs, then no string of length 6 would be a valid program.
This is probably getting away from the core points though
(You could have the programming language be such that, e.g. 00XXXXX outputs the bits XXXXX, and 01XXXXXX outputs the bits XXXXXX, and other programs start with a 1, and any other program might want to encode is somehow encoded using some scheme)
the priors for each models will be 2^-5 for model A, 2^-6 for model B and 2^-4 for model C, according to their Kolmogorov complexity?
yeah, the (non-normalized) prior for each will be 2^(-(length of a program which directly encodes a 5 bit string to output)) for the programs which directly encode some 5 bit string and output it, 2^(-(length of a program which directly encodes a 6 bit string to output)) for the programs which directly encode some 6 bit string and output it, and (say) 2^(-4) for program C.
And those likelihoods you gave are all correct for those models.

So, then, the posteriors (prior to normalization)
would be 2^(-(length of a program which directly encodes a 5 bit string to output)) (let’s say this is 2^(-7) for the program that essentially is print(“HTHHT”),
2^(-(length of a program which directly encodes a 6 bit string to output)) (let’s say this is 2^(-8) ) for the programs that essentially are print(“HTHHTH”) and print(“HTHHTT”) respectively
2^(-4) * 2^(-5) = 2^(-9) for model C.
If we want to restrict to these 4 programs, then, adding these up, we get 2^(-7) + 2^(-8) + 2^(-8) + 2^(-9) = 2^(-6) + 2^(-9) = 9 * 2^(-9), and dividing that, we get
(4/9) chance for the program that hardcodes HTHHT (say, 0010110)
(2/9) chance for the program that hardcodes HTHHTH (say, 01101101)
(2/9) chance for the program that hardcodes HTHHTT (say, 01101100)
(1/9) chance for the program that produces a random 5 bit string. (say, 1000)
So, in this situation, where we’ve restricted to these programs, the posterior probability distribution for “what is the next bit” would be
(4/9)+(1/9)=(5/9) chance that “there is no next bit” (this case might usually be disregarded/discared, idk.)
(2/9) chance that the next bit is H
(2/9) chance that the next bit is T

drocta 10 Jan 2024 2:45 UTC
1 point
0
in reply to: RogerDearnaley’s comment on: What’s the protocol for if a novice has ML ideas that are unlikely to work, but might improve capabilities if they do work?
Thanks! The specific thing I was thinking about most recently was indeed specifically about context length, and I appreciate the answer tailored to that, as it basically fully addresses my concerns in this specific case.
However, I also did mean to ask the question more generally. I kinda hoped that the answers might also be helpful to others who had similar questions (as well as if I had another idea meeting the same criteria in the future), but maybe thinking other people with the same question would find the question+answers here, was not super realistic, idk.

drocta 10 Jan 2024 2:11 UTC
4 points
1
on: Questions about Solomonoff induction
Here is my understanding:
we assume a programming language where a program is a finite sequence of bits, and such that no program is a prefix of another program. So, for example, if 01010010 is a program, then 0101 is not a program.
Then, the (not-normalized) prior probability for a program is $2^{- length (the program)}$
Why that probability?
If you take any infinite sequence of bits, then, because no program is a prefix of any other program, at most one program will be a prefix of that sequence of bits.
If you randomly (with uniform distribution) select an infinite sequence of bits, the probability that the sequence of bits has a particular program as a prefix, is then $2^{- length (the program)}$ (because there’s a factor of (1/2) for each of the bits of the program, and if the first (length of the program) bits match the program, then it doesn’t matter what the rest of the bits that come after are.
(Ah, I suppose you don’t strictly need to talk about infinite sequences of bits, and you could just talk about randomly picking the value of the next bit, stopping if it ever results in a valid program in the programming language..., not sure which makes it easier to think about.)

If you want this to be an actual prior, you can normalize this by dividing by (the sum over all programs, of $2^{- length (the program)}$ ).
The usual way of defining Solomonoff induction, I believe has the programs being deterministic, but I’ve read that allowing them to use randomness has equivalent results, and may make some things conceptually easier.
So, I’ll make some educated guesses about how to incorporate the programs having random behavior.
Let G be the random variable for “which program gets selected”, and g be used to refer to any potential particular value for that variable. (I avoided using p for program because I want to use it for probability. The choice of the letter g was arbitrary.)
Let O be the random variable for the output observed, and let o be used for any particular value for that variable.
$P (G = g | O = o) = P (G = g \land O = o) / P (O = o)$
$= P (O = o | G = g) P (G = g) / P (O = o)$
And, given a program g, the idea of P(O=o|G=g) makes sense, and P(G=g) is proportional to $2^{- length (g)}$ (missing a normalization constant, but this will be the same across all g),
And, P(O=o) will also be a normalization constant that is the same across all g.
And so, if you can compute values P(O=o|G=g) (the program g may take too long to run in practice) we can compute values proportional to P(G=g|O=o) .
Does that help any?
(apologies if this should be a “comment” rather than an “answer”. Hoping it suffices.)

drocta 19 Jun 2023 21:53 UTC
2 points
0
in reply to: Jeremy Gillen’s comment on: Infrafunctions and Robust Optimization
Well, I was kinda thinking of $ν$ as being, say, a distribution of human behaviors in a certain context (as filtered through a particular user interface), though, I guess that way of doing it would only make sense within limited contexts, not general contexts where whether the agent is physically a human or something else, would matter. And in this sort of situation, well, the action of “modify yourself to no-longer be a quantilizer” would not be in the human distribution, because the actions to do that are not applicable to humans (as humans are, presumably, not quantilizers, and the types of self-modification actions that would be available are not the same). Though, “create a successor agent” could still be in the human distribution.
Of course, one doesn’t have practical access to “the true probability distribution of human behaviors in context M”, so I guess I was imagining a trained approximation to this distribution.
Hm, well, suppose that the distribution over human-like behaviors includes both making an agent which is a quantilizer and making one which isn’t, both of equal probability. Hm. I don’t see why a general quantilizer in this case would pick the quantilizer over the plain optimizer, as the utility...
Hm...
I get the idea that the “quantilizers correspond to optimizing an infra-function of form [...]” thing is maybe dealing with a distribution over a single act?
Or.. if we have a utility function over histories until the end of the episode, then, if one has a model of how the environment will be and how one is likely to act in all future steps, given each of one’s potential actions in the current step, one gets an expected utility conditioned on each of the potential actions in the current step, and this works as a utility function over actions for the current step,
and if one acts as a quantilizer over that, each step.. does that give the same behavior as an agent optimizing an infra-function defined using the condition with the $L_{1}$ norm described in the post, in terms of the utility function over histories for an entire episode, and reference distributions for the whole episode?
argh, seems difficult...

drocta 19 Jun 2023 21:09 UTC
1 point
0
on: Infrafunctions and Robust Optimization
For the “Crappy Optimizer Theorem”, I don’t understand why condition 4, that if $f \leq 0$ , then $Q (s) (f) \leq 0$ , isn’t just a tautology^[1]. Surely if $\forall x \in X, f (x) \leq c$ , then no-matter what $s : (X \to R) \to X$ is being used,
as $Q (s) (f) := f (s (f))$ , then letting $x = s (f)$ , then $f (x) \leq c$ , and so $Q (s) (f) = f (s (f)) = f (x) \leq c$ .
I guess if the 4 conditions are seen as conditions on a function $F : (X \to R) \to R$ (where they are written for $F = Q (s)$ ), then it no-longer is automatic, and it is just when specifying that $F = Q (s)$ for some $s$ , that condition 4 becomes automatic?
______________
[start of section spitballing stuff based on the crappy optimizer theorem]
Spitball 1:
What if instead of saying $s : (X \to R) \to X$ , we had $s : (X \to R) \to Δ X$ ? would we still get the results of the crappy optimizer theorem?
If we define if s(f) is now a distribution over X, then, I suppose instead of writing Q(s)(f)=f(s(f)) should write Q(s)(f) = s(f)(f) , and, in this case, the first 2 and 4th conditions seem just as reasonable. The third condition… seems like it should also be satisfied?
Spitball 2:
While I would expect that the 4 conditions might not be exactly satisfied by, e.g. gradient descent, I would kind of expect basically any reasonable deterministic optimization process to at least “almost” satisfy them? (like, maybe gradient-descent-in-practice would fail condition 1 due to floating point errors, but not too badly in reasonable cases).
Do you think that a modification of this theorem for functions Q(s) which only approximately satisfy conditions 1-3, would be reasonably achievable?
______________
1. ^
  I might be stretching the meaning of “tautology” here. I mean something provable in our usual background mathematics, and which therefore adding it as an additional hypothesis to a theorem, doesn’t let us show anything that we couldn’t show without it being an explicit hypothesis.

drocta 19 Jun 2023 20:24 UTC
2 points
0
in reply to: Jeremy Gillen’s comment on: Infrafunctions and Robust Optimization
I thought CDT was considered not reflectively-consistent because it fails Newcomb’s problem?
(Well, not if you define reflective stability as meaning preservation of anti-Goodhart features, but, CDT doesn’t have an anti-Goodhart feature (compared to some base thing) to preserve, so I assume you meant something a little broader?)
Like, isn’t it true that a CDT agent who anticipates being in Newcomb-like scenarios would, given the opportunity to do so, modify itself to be not a CDT agent? (Well, assuming that the Newcomb-like scenarios are of the form “at some point in the future, you will be measured, and based on this measurement, your future response will be predicted, and based on this the boxes will be filled”)
My understanding of reflective stability was “the agent would not want to modify its method of reasoning”. (E.g., a person with an addiction is not reflectively stable, because they want the thing (and pursue the thing), but would rather not want (or pursue) the thing.
The idea being that, any ideal way of reasoning, should be reflectively stable.
And, I thought that what was being described in the part of this article about recovering quantilizers, was not saying “here’s how you can use this framework to make quantalizers better”, so much as “quantilizers fit within this framework, and can be described within it, where the infrafunction that produces quantilizer-behavior is this one: [the (convex) set of utility functions which differ (in absolute value) from the given one, by, in expectation under the reference policy, at most epsilon]”
So, I think the idea is that, a quantilizer for a given utility function $U$ and reference distribution $ν$ is, in effect, optimizing for an infrafunction that is/corresponds-to the set of utility functions $V$ satisfying the bound in question,
and, therefore, any quantilizer, in a sense, is as if it “has this bound” (or, “believes this bound”)
And that therefore, any quantilizer should -
- wait.. that doesn’t seem right..? I was going to say that any quantilizer should therefore be reflectively stable, but that seems like it must be wrong? What if the reference distribution includes always taking actions to modify oneself in a way that would result in not being a quantilizer? uhhhhhh
Ah, hm, it seems to me like the way I was imagining the distribution $ν$ and the context in which you were considering it, are rather different. I was thinking of $ν$ as being an accurate distribution of behaviors of some known-to-be-acceptably-safe agent, whereas it seems like you were considering it as having a much larger support, being much more spread out in what behaviors it has as comparably likely to other behaviors, with things being more ruled-out rather than ruled-in ?

drocta 5 Jun 2023 22:57 UTC
1 point
0
in reply to: Erik Jenner’s comment on: Research agenda: Formalizing abstractions of computations
Whoops, yes, that should have said $f (a) \to_{B} f (a^{'})$ , thanks for the catch! I’ll edit to make that fix.
Also, yes, what things between $a$ and $a^{'}$ should be sent to, is a difficulty..
A thought I had which, on inspection doesn’t work, is that (things between $a$ and $a^{'}$ ) could be sent to $f (a^{'})$ , but that doesn’t work, because $a^{'}$ might be terminal, but (thing between $a$ and $a^{'}$ ) isn’t terminal. It seems like the only thing that would always work would be for them to be sent to something that has an arrow (in B) to $f (a^{'})$ (such as f(a), as you say, but, again as you mention, it might not be viable to determine f(a) from the intermediary state).
I suppose if $f$ were a partial function, and one such that all states not in its domain have a path to a state which is in its domain, then that could resolve that?
I think equivalently to that, if you modified the abstraction to get, $(B^{'}, \to_{B^{'}})$ defined as, $B^{'} := {b, p r e (b) | b \in B}$ and $(x \to_{B^{'}} y) iff (((x, y \in B) \land (x \to_{B})) \lor ((y \in B) \land (x = p r e (y))))$
so that B’ has a state for each state of B, along with a second copy of it with no in-going arrows and a single arrow going to the normal version,
uh, I think that would also handle it ok? But this would involve modifying the abstraction, which isn’t nice. At least the abstraction embeds in the modified version of it though.
Though, if this is equivalent to allowing f to be partial, with the condition that anything not in its domain have arrows leading to things that are in its domain, then I guess it might help to justify a definition allowing $f$ to be partial, provided it satisfies that condition.
Are these actually equivalent?
Suppose $f : A \to B$ is partial and satisfies that condition.
Then, define $f^{'} : A \to B^{'}$ to agree with f on the domain of f, and for other $a$ , pick an $a^{'}$ in the domain of f such that $a {* \to}_{A} a^{'}$ , and define $f^{'} (a) = p r e (f (a^{'}))$
In a deterministic case, should pick $a^{'}$ to be the first state in the path starting with $a$ to be in the domain of $f$ . (In the non-deterministic case, this feels like something that doesn’t work very well...)
Then, for any non-terminal $a \in A$ , either it is in the domain of f, in which case we have the existence of $a^{'} \in A$ such that a ${* \to}_{A} a^{'}$ and where $f^{'} (a) = f (a) \to_{B^{'}} f (a^{'}) = f^{'} (a^{'})$ , or it isn’t, in which case we have that there exists $a^{'} \in A$ such that a ${* \to}_{A} a^{'}$ and where $f^{'} (a) = p r e (f (a^{'})) \to_{B^{'}} f^{'} (a^{'}) = f (a^{'})$ , and so f’ satisfies the required condition.
On the other hand, if we have an $f^{'} : A \to B^{'}$ satisfying the required condition, we can co-restrict it to B, giving a partial function $f : A \to B$ , where, if $a$ isn’t in the domain of f, then, assuming a is non-terminal, we get some $a^{''} \in A$ s.t. a ${* \to}_{A} a^{''}$ and where $f^{'} (a) \to_{B^{'}} f^{'} (a^{''})$ , and, as the only things in B’ which have any arrows going in are elements of B, we get that f’(a″) is in B, and therefore that a″ is in the domain of f.
But what if a is terminal? Well, if we require that $f^{'} (a)$ non-terminal implies $a$ non-terminal, then this won’t be an issue because pre(b) is always non-terminal, and so anything terminal is in the domain.
Therefore the co-restriction f of f’, does yield a partial function satisfying the proposed condition to require for partial maps.
So, this gives a pair of maps, one sending functions $f^{'} : A \to B^{'}$ satisfying appropriate conditions to partial function $f : A \to B$ satisfying other conditions, and one sending the other way around, and where, if the computations are deterministic, these two are inverses of each-other. (if not assuming deterministic, then I guess potentially only a one-sided inverse?)
So, these two things are equivalent.
uh… this seems a bit like an adjunction, but, not quite. hm.

drocta 4 Jun 2023 21:47 UTC
1 point
0
on: Research agenda: Formalizing abstractions of computations
A thought on the “but what if multiple steps in the actual-algorithm correspond to a single step in an abstracted form of the algorithm?” thing :
This reminds me a bit of, in the topic of “Abstract Rewriting Systems”, the thing that the $* \to$ vs $\to$ distinction handles. (the asterisk just indicating taking the transitive reflexive closure)
Suppose we have two abstract rewriting systems $(A, \to_{A})$ and $(B, \to_{B})$ .
(To make it match more closely what you are describing, we can suppose that every node has at most one outgoing arrow, to make it fit with how you have timesteps as functions, rather than being non-deterministic. This probably makes them less interesting as ARSs, but that’s not a problem)
Then, we could say that $f : A \to B$ is a homomorphism (I guess) if,
for all $a \in A$ such that $a$ has an outgoing arrow, there exists $a^{'} \in A$ such that $a {* \to}_{A} a^{'}$ and $f (a) \to_{B} f (a^{'})$ .
These should compose appropriately [err, see bit at the end for caveat], and form the morphisms of a category (where the objects are ARSs).
I would think that this should handle any straightforward simulation of one Turing machine be another.
As for whether it can handle complicated disguise-y ones, uh, idk? Well, if it like, actually simulates the other Turing machine, in a way where states of the simulated machine have corresponding states in the simulating machine, which are traversed in order, then I guess yeah. If the universal Turing machine instead does something pathological like, “search for another Turing machine along with a proof that the two have the same output behavior, and then simulate that other one”, then I wouldn’t think it would be captured by this, but also, I don’t think it should be?
This setup should also handle the circuits example fine, and, as a bonus(?), can even handle like, different evaluation orders of the circuit nodes, if you allow multiple outgoing arrows.
And, this setup should, I think, handle anything that the “one step corresponds to one step” version handles?
It seems to me like this set-up, should be able to apply to basically anything of the form “this program implements this rough algorithm (and possibly does other stuff at the same time)”? Though to handle probabilities and such I guess it would have to be amended.
I feel like I’m being overconfident/presumptuous about this, so like,
sorry if I’m going off on something that’s clearly not the right type of thing for what you’re looking for?
__________
Checking that it composes:
suppose A, B, C, $f : A \to B, g : B \to C$
then for any $a \in A$ which has an outgoing arrow and where f(a) has an outgoing arrow, $g (f (a)) \to_{C} b^{'}$ where $f (a) {* \to}_{B} b^{'}$
so either b’ = f(a) or there is some sequence $b_{0} = f (a), b_{1}, . . ., b_{n} = b^{'}$ where $b_{i} \to_{B} b_{i + 1}$ , and so therefore,
Ah, hm, maybe we need an additional requirement that the maps be surjective?
or, hm, as we have the assumption that $a$ has an outward arrow,
then we get that there is an $a^{'}$ s.t. $a {* \to}_{A} a^{'}$ and s.t. $f (a) = b_{0} \to_{B} b_{1} = f (a^{'})$
ok, so, I guess the extra assumption that we need isn’t quite “the maps are surjective”, so much as, “the maps f are s.t. if f(a) is a non-terminal state, then f(a) is a non-terminal state”, where “non-terminal state” means one with an outgoing arrow. This seems like a reasonable condition to assume.

drocta 30 May 2023 17:06 UTC
2 points
0
in reply to: Yaakov T’s comment on: All AGI Safety questions welcome (especially basic ones) [May 2023]
In the line that ends with “even if God would not allow complete extinction.”, my impulse is to include ” (or other forms of permanent doom)” before the period, but I suspect that this is due to my tendency to include excessive details/notes/etc. and probably best not to actually include in that sentence.
(Like, for example, if there were no more adult humans, only billions of babies grown in artificial wombs (in a way staggered in time) and then kept in a state of chemically induced euphoria until the age of 1, and then killed, that technically wouldn’t be human extinction, but, that scenario would still count as doom.)
Regarding the part about “it is secular scientific-materialists who are doing the research which is a threat to my values” part: I think it is good that it discusses this! (and I hadn’t thought about including it)
But, I’m personally somewhat skeptical that CEV really works as a solution to this problem? Or at least, in the simpler ways of it being described.
Like, I imagine there being a lot of path-dependence in how a culture’s values would “progress” over time, and I see little reason why a sequence of changes of the form “opinion/values changing in response to an argument that seems to make sense” would be that unlikely to produce values that the initial values would deem horrifying? (or, which would seem horrifying to those in an alternate possible future that just happened to take a difference branch in how their values evolved)
[EDIT: at this point, I start going off on a tangent which is a fair bit less relevant to the question of improving Stampy’s response, so, you might want to skip reading it, idk]
My preferred solution is closer to, “we avoid applying large amounts of optimization pressure to most topics, instead applying it only to topics where there is near-unanimous agreement on what kinds of outcomes are better (such as, “humanity doesn’t get wiped out by a big space rock”, “it is better for people to not have terrible diseases”, etc.), while avoiding these optimizations having much effect on other areas where there is much disagreement as to what-is-good.

Though, it does seem plausible to me, as a somewhat scary idea, that the thing I just described is perhaps not exactly coherent?
(that being said, even though I have my doubts about CEV, at least in the form described in the simpler ways it is described, I do think it would of course be better than doom.
Also, it is quite possible that I’m just misunderstanding the idea of CEV in a way that causes my concerns, and maybe it was always meant to exclude the kinds of things I describe being concerned about?)

drocta 9 May 2023 19:08 UTC
9 points
0
in reply to: mruwnik’s comment on: All AGI Safety questions welcome (especially basic ones) [May 2023]
I want to personally confirm a lot of what you’ve said here. As a Christian, I’m not entirely freaked out about AI risk because I don’t believe that God will allow it to be completely the end of the world (unless it is part of the planned end before the world is remade? But that seems unlikely to me.), but that’s no reason that it can’t still go very very badly (seeing as, well, the Holocaust happened).
In addition, the thing that seems to me most likely to be the way that God doesn’t allow AI doom, is for people working on AI safety to succeed. One shouldn’t rely on miracles and all that (unless [...]), so, basically I think we should plan/work as if it is up to humanity to prevent AI doom, only that I’m a bit less scared of the possibility of failure, but I would hope only in a way that results in better action (compared to panic) rather than it promoting inaction.
(And, a likely alternative, if we don’t succeed, I think of as likely being something like,
really-bad-stuff happens, but then maybe an EMP (or many EMPs worldwide?) gets activated, solving that problem, but also causing large-scale damage to power-grids, frying lots of equipment, and causing many shortages of many things necessary for the economy, which also causes many people to die. idk.)

drocta 21 Apr 2023 17:35 UTC
1 point
0
in reply to: ShardPhoenix’s comment on: Mechanistically interpreting time in GPT-2 small
I don’t understand why this comment has negative “agreement karma”. What do people mean by disagreeing with it? Do they mean to answer the question with “no”?

drocta 3 Jan 2023 22:28 UTC
3 points
0
on: Verification Is Not Easier Than Generation In General
First, I want to summarize what I understand to be what your example is an example of:
”A triple consisting of
1) A predicate P
2) the task of generating any single input x for which P(x) is true
3) the task of, given any x (and given only x, not given any extra witness information), evaluating whether P(x) is true
”
For such triples, it is clear, as your example shows, that the second task (the 3rd entry) can be much harder than the first task (the 2nd entry).
_______
On the other hand, if instead one had the task of producing an exhaustive list of all x such that P(x), this, I think, cannot be easier that verifying whether such a list is correct (provided that one can easily evaluate whether x=y for whatever type x and y come from), as one can simply generate the list, and check if it is the same list.
Another question that comes to mind is: Are there predicates P such that the task of verifying instances which can be generated easily, is much harder than the task of verifying those kinds of instances?
It seems that the answer to this is also “yes”: Consider P to be “is this the result of applying this cryptographic hash function to (e.g.) a prime number?”. It is fairly easy to generate large prime numbers, and then apply the hash function to it. It is quite difficult to determine whether something is the hash of a prime number (… maybe assume that the hash function produces more bits for longer inputs in order to avoid having pigeonhole principle stuff that might result in it being highly likely that all of the possible outputs are the hash of some prime number. Or just put a bound on how big the prime numbers can be in order for P to be true of the hash.)
(Also, the task of “does this machine halt”, given a particular verifying process that only gets the specification of the machine and not e.g. a log of it running, should probably(?) be reasonably easy to produce machines that halt but which that particular verifying process will not confirm that quickly.
So, for any easy-way-to-verify there is an easy-way-to-generate which produces ones that the easy-way-to-verify cannot verify, so that seems to be another reason why “yes”, though, there may be some subtleties here?)

drocta 29 Sep 2022 4:32 UTC
1 point
−2
on: Attempts at Forwarding Speed Priors
As you know, there’s a straightforward way to, given any boolean circuit, to turn it into a version which is a tree, by just taking all the parts which have two wires coming out from a gate, and making duplicates of everything that leads into that gate.
I imagine that it would also be feasible to compute the size of this expanded-out version without having to actually expand out the whole thing?
Searching through normal boolean circuits, but using a cost which is based on the size if it were split into trees, sounds to me like it would give you the memoization-and-such speedup, and be kind of equivalent theoretically to using the actual trees?
A modification of it comes to mind. What if you allow some gates which have multiple outputs, but don’t allow gates which duplicate their input? Or, specifically, what if you allow something like toffoli gates as well as the ability to just discard an output? The two parts of the output would be sorta independent due to the gate being invertible (… though possibly there could be problems with that due to original input being used more than once?)
I don’t know whether this still has the can-do-greedy-search properties you want, but it seems like it might in a sense prevent using some computational result multiple times (unless having multiple copies of initial inputs available somehow breaks that).

drocta 10 Jul 2022 5:18 UTC
1 point
on: Visualizing Neural networks, how to blame the bias
It seems like the 5th sentence has its ending cut off? “it tries to parcel credit and blame for a decision up to the input neurons, even when credit and blame” , seems like it should continue [do/are x] for some x.

drocta 27 Jun 2022 23:07 UTC
2 points
on: A Toy Model of Gradient Hacking
When you say “which yields a solution of the form $f (w) = c_{1} / (1 - w) + c_{2}$ ”, are you saying that $f^{'} (w) / f (w) = 1 / (1 - w)$ yields that, or are you saying that $(1 - w) f^{'} (w) - f (w) > 0$ yields that? Because, for the former, that seems wrong? Specifically, the former should yield only things of the form $f (w) = c_{1} / (1 - w)$ .
But, if the latter, then, I would think that the solutions would be more solutions than that?
Like, what about $g (w) := c_{1} / (1 - w) + c_{2} \cdot (1 - \frac{1}{10^{6}} + \frac{1}{10^{6}} cos (w))$ ? (where, say, $c_{1} = ε + δ$ and $c_{2} = - δ$
$g^{'} (w) = \frac{c_{1}}{(1 - w)^{2}} + c_{2} \cdot (- \frac{1}{10^{6}} sin (w))$ . so $(1 - w) g^{'} (w) - g (w) = c_{2} \cdot (- \frac{1}{10^{6}} (1 - w) sin (w)) - c_{2} \cdot (1 - \frac{1}{10^{6}} + \frac{1}{10^{6}} cos (w))$
$= - c_{2} \cdot (1 - 10^{- 6} \cdot (1 - cos (w) - (1 - w) sin (w)))$
which, for $c_{2} < 0$ , and $w \in [0, 1]$ , is positive, and so g should also be a solution to $(1 - w) f^{'} (w) - f (w) > 0$ , yes?
Or, were you just giving a subset of the solutions, of the differential inequality, which were all the ones you needed to make the point?
Separately (btw, what’s the convention if one has unrelated comments? to put them in one comment or separate comments?) :
As for how the network could detect something about its current weights, if it is a recurrent network, this seems like something that some form of this should be learnable.
Suppose you set up the architecture for a recurrent neural network, and pick some arbitrary linear combination (but where the coefficients aren’t especially big) of the weights in the network, and then for the loss function, take the main part of the network’s output as doing some normal task, and then another part of the output be judged for how well it approximates the current value of the linear combination of all the network’s weights, with the initially chosen coefficients. It seems plausible to me that this would do well. Of course, one way it might fail to work properly is if this linear combination ends up becoming roughly constant, or just if some weights stop changing during the training, leading to this second output not getting the signal needed to learn that part. Maybe if you used dropout and took that which weights were dropped out when evaluating the weighted sum of the weights (counting them as zero) in the loss, it could fix that issue. (dropout being done the same in each recurrence, not separately.)
Why “a linear combination of the weights” instead of the particular weights? Well, I imagine getting all the individual weights would be not particularly feasible unless the architecture was specifically designed to do that (like in the architectures for those quine-ing neural nets), but, if we are looking at a mix between “how the net should be”, and “a net that is doing gradient hacking”, then it seems like “some particular weighted sum of the weights”, might be all that would be needed. Or perhaps two weighted sums with different coefficients if having the $w_{1}$ and $w_{2}$ separate.
On the other hand, if the network isn’t recurrent, or if all the recurrence is done in a vector-quantization-y way, I would imagine it would be more difficult for the network to estimate a given linear combination of its current weights. (Though, if the linear combination of weights is only of weights before a certain layer, then layers after that layer might be able to approximate it without any recurrence, but, the layers that do and use this approximation could be modified without this being detected, and therefore, I’d think it couldn’t protect these later parts from being changed by gradient descent, or at least, it would be harder.)

(I’m imagining, if people are trying to make this sort of thing work, that these networks are using just RELU, not like a smoothed version of RELU, so that the values of the weights are reflected more piecewise-linearly in the activations of one layer, given activations in the previous layer, which I think would facilitate estimating other linear combinations of the weights between the previous layers, and as such also for estimating this for a linear combination of weights in any layer.)

drocta 10 Jun 2022 0:56 UTC
8 points
on: How Do Selection Theorems Relate To Interpretability?
As another “why not just” which I’m sure there’s a reason for:
in the original circuits thread, they made a number of parameterized families of synthetic images which certain nodes in the network responded strongly to in a way that varied smoothly with the orientation parameter, and where these nodes detected e.g. boundaries between high-frequency and low-frequency regions at different orientations.
If given another such network of generally the same kind of architecture, if you gave that network the same images, if it also had analogous nodes, I’d expect those nodes to have much more similar responses to those images than any other nodes in the network. I would expect that cosine similarity of the “how strongly does this node respond to this image” would be able to pick out the node(s) in question fairly well? Perhaps I’m wrong about that.
And, of course, this idea seems only directly applicable to feed-forward convolution networks that take an image as the input, and so, not so applicable when trying to like, understand how an agent works, probably.
(well, maybe it would work in things that aren’t just a convolutions-and-pooling-and-dilation-etc , but seems like it would be hard to make the analogous synthetic inputs which exemplify the sort of thing that the node responds to, for inputs other than images. Especially if the inputs are from a particularly discrete space, like sentences or something. )
But, this makes me a bit unclear about why the “NP-HARD” lights start blinking.
Of course, “find isomorphic structure”, sure.
But, if we have a set of situations which exemplify when a given node does and does not fire (rather, when it activates more and when it activates less) in one network, searching another network for a node that does/doesn’t activate in those same situations, hardly seems NP-hard. Just check all the nodes for whether they do or don’t light up. And then, if you also have similar characterizations for what causes activation in the nodes that came before the given node in the first network, apply the same process with those on the nodes in the second network that come before the nodes that matched the closest.
I suppose if you want to give a overall score for each combination of “this sub-network of nodes in the new network corresponds to this other network of nodes in the old-and-understood network”, and find the sub-network that gives the best score, then, sure, there could be exponentially many sub-networks to consider. But, if each well-understood node in the old network generally has basically only one plausibly corresponding node in the new network, then this seems like it might not really be an issue in practice?
But, I don’t have any real experience with this kind of thing, and I could be totally off.

drocta 31 May 2022 19:58 UTC
2 points
on: Paper: Teaching GPT3 to express uncertainty in words
I was surprised by how the fine-tuning was done for the verbalized confidence.
My initial expectation was that it would make the loss be based on like, some scoring rule based on the probability expressed and the right answer.
Though, come to think of it, I guess seeing as it would be assigning logits values to different expressions of probabilities, it would have to… what, take the weighted average of the scores it would get if it gave the different probabilities? And, I suppose that if many training steps were done on the same question/answer pairs, then the confidences might just get pushed towards 0% or 100%?
Ah, but for the indirect logit it was trained using the “is it right or wrong” with the cross-entropy loss thing. Ok, cool.

drocta 14 May 2022 22:53 UTC
1 point
on: An observation about Hubinger et al.’s framework for learned optimization
For $m : S$ such that $m$ is a mesa=optimizer let $Σ_{m}$ be the space it optimizes over, and $g_{m} : Σ_{m} \to R$ be its utility function .
I know you said “which we need not notate”, but I am going to say that for $s : S$ and $x : X$ , that $s (x) : A$ , and $A$ is the space of actions (or possibly, $s (x) : A_{x}$ and $A_{x}$ is the space of actions available in the situation $x$ )
(Though maybe you just meant that we need note notate separately from s, the map from X to A which s defines. In which case, I agree, and as such I’m writing $s (x) : A$ instead of saying that something belongs to the function space $X \to A$ . )
For $m : S$ to have its optimization over $Σ_{m}$ have any relevance, there has to be some connection between the chosen $σ : Σ_{m}$ (chosen by m) , and $m (x)$ .
So, the process by which m produces m(x) when given x, should involve the selected $σ$ .
Moreover, the selection of the $σ$ ought to depend on x in some way, as otherwise the choice of $σ$ is constant each time, and can be regarded as just a constant value in how m functions.
So, it seems that what I said was $g_{m} : Σ_{m} \to R$ should instead be either $g_{m} : X \times Σ_{m} \to R$ , or $g_{m, x} : Σ_{m, x} \to R$ (in the latter case I suppose one might say $g_{m} : \sum x : X (Σ_{m, x}) \to R$ )
Call the process that produces the action $m (x) : A$ using the choice of $σ : Σ_{m}$ by the name $h_{m} : X \times Σ_{m} \to A$
(or more generally, $h_{m} : \sum x : X (Σ_{m, x}) \to A$ ) .
$h_{m}$ is allowed to also use randomness in addition to $x$ and $σ$ . I’m not assuming that it is a deterministic function. Though come to think of it, I’m not sure why it would need to be non-deterministic? Oh well, regardless.
Presumably whatever $f : S \to R$ is being used to select $s : S$ , depends primarily (though not necessarily exclusively) on what s(x) is for various values of x, or at least on something which indicates things about that, as f is supposed to be for selecting systems which take good actions?
Supposing that for the mesa-optimizer $m$ that the inner optimization procedure (which I don’t have a symbol for) and the inner optimization goal (i.e. $g_{m}$ ) are separate enough, one could ask “what if we had m, except with $g_{m}$ replaced with $g_{m}^{'}$ , and looked at how the outputs of $h_{m} (x, σ)$ and $h_{m} (x, σ^{'})$ differ, where $σ$ and $σ^{'}$ are respectively are selected (by m’s optimizer) by optimizing for the goals $g_{m}$ , and $g_{m}^{'}$ respectively?”.
Supposing that we can isolate the part of how f(s) depends on s which is based on what $s (x)$ is or tends to be for different values of $x$ , then there would be a “how would $f (m)$ differ if m used $g_{m}^{'}$ instead of $g_{m}$ ?”.
If $g_{m}^{'}$ in place of $g_{m}$ would result in things which, according to how $f$ works, would be better, then it seems like it would make sense to say that $g_{m}$ isn’t fully aligned with $f$ ?
Of course, what I just described makes a number of assumptions which are questionable:
- It assumes that there is a well-defined optimization procedure that m uses which is cleanly separable from the goal which it optimizes for
- It assumes that how f depends on s can be cleanly separated into a part which depends on (the map in $X \to A$ which is induced by $s$ ) and (the rest of the dependency on $s$ )
The first of these is also connected to another potential flaw with what I said, which is, it seems to describe the alignment of the combination of (the optimizer m uses) along with $g_{m}$ , with $f$ , rather than just the alignment of $g_{m}$ with $f$ .
So, alternatively, one might say something about like, disregarding how the searching behaves and how it selects things that score well at the goal $g_{m}$ , and just compare how $h_{m} (x, σ)$ and $h_{m} (x, σ^{'})$ tend to compare when $σ$ and $σ^{'}$ are generic things which score well under $g_{m}$ and $g_{m}^{'}$ respectively, rather than using the specific procedure that $m$ uses to find something which scores well under $g_{m}$ , and this should also, I think, address the issue of $m$ possibly not having a cleanly separable “how it optimizes for it” method that works for generic “what it optimizes for”.
The second issue, I suspect to not really be a big problem? If we are designing the outer-optimizer, then presumably we understand how it is evaluating things, and understand how that uses the choices of $s (x) : A$ for different $x : X$ .
I may have substantially misunderstood your point?
Or, was your point that the original thing didn’t lay these things out plainly, and that it should have?
Ok, reading more carefully, I see you wrote
I can certainly imagine that it may be possible to add in details on a case-by-case basis or at least to restrict to a specific explicit class of base objectives and then explicitly define how to compare mesa-objectives to them.
and the other things right before and after that part, and so I guess something like “it wasn’t stated precisely enough for the cases it is meant to apply to / was presented as applying as a concept more generally than made sense as it was defined” was the point and which I had sorta missed it initially.
(I have no expertise in these matters; unless shown otherwise, assume that in this comment I don’t know what I’m talking about.)

drocta 26 Sep 2021 19:41 UTC
1 point
in reply to: CronoDAS’s comment on: A Semitechnical Introductory Dialogue on Solomonoff Induction
Is this something that the infra-bayesianism idea could address? So, would an infra-bayesian version of AIXI be able to handle worlds that include halting oracles, even though they aren’t exactly in its hypothesis class?

drocta 8 Aug 2021 23:44 UTC
1 point
on: Seeking Power is Convergently Instrumental in a Broad Class of Environments
Do I understand correctly that in general the elements of A, B, C, are achievable probability distributions over the set of n possible outcomes? (But that in the examples given with the deterministic environments, these are all standard basis vectors / one-hot vectors / deterministic distributions ?)
And, in the case where these outcomes are deterministic, and A and B are disjoint, and A is much larger than B, then given a utility function on the possible outcomes in A or B, a random permutation of this utility function will, with high probability, have the optimal (or a weakly optimal) outcome be in A?
(Specifically, if I haven’t messed up, if asymptotically (as |B| goes to infinity) $\frac{| B |^{2}}{| A | + 1} \to 0$ then the probability of there being something in A which is weakly better than anything in B goes to 1 , and if $\frac{| B |^{2}}{| A | + 1} \to r$ then the probability goes to at least $e^{- r}$ , I think?
Coming from $\frac{(\frac{| A |}{| B |}) | B |! | A |!}{(| A | + | B |)!} = \frac{| A |!}{(| A | - | B |)!} \frac{| A |!}{(| A | + | B |)!} = \prod_{k = 0}^{| B | - 1} \frac{| A | - k}{| A | + | B | - k} = \prod_{k = 0}^{| B | - 1} (1 - \frac{| B |}{| A | + | B | - k})$ )
While I’d readily believe it, I don’t really understand why this extends to the case where the elements of A and B aren’t deterministic outcomes but distributions over outcomes. Maybe I need to review some of the prior posts.
Like, what if every element of A was a probability distribution with over 3 different observation-histories (each with probability ¹⁄₃) , and every element of B was a probability distribution over 2 different observation-histories (each with probability ¹⁄₂)? (e.g. if one changes pixel 1 at time 1, then in addition to the state of the pixel grid, one observes at random either a orange light or a purple light, while if one instead changes pixel 2 at time 1, in addition to the pixel grid state, one observes at random either a red, green, or blue light, in addition to the pixel grid) Then no permutation of the set of observations-histories would convert any element of A into an element of B, nor visa versa.