0:00
think like one issue is if you have a bunch of nodes of
0:03
parallelization available to you, then it's very easy to just
0:06
have multiple auto researchers talking through a common system
0:09
or something like that. When I was more interested in is how
0:11
you can have an untrusted pool of workers out there on the
0:14
internet. So for example, in auto research, you're just trying
0:18
to find the piece of code that trains a model to a very low
0:22
validation loss. If anyone gives you a candidate commit, it's
0:26
very easy to verify that that commit is correct. It's good. Like
0:29
they, someone could claim from the internet that this piece of
0:32
code will optimize much better and give you much better
0:34
performance. You can just check it very easy, but probably a
0:37
lot of work goes into that checking. But fundamentally, they
0:40
can lie and etc. So you're basically dealing with a
0:43
similar kind of, it's almost actually like looks a little bit
0:45
like my, my designs that incorporate an untrusted pool of
0:47
workers, actually look a little bit more like a blockchain a
0:51
little bit, because instead of blocks, you have commits, and
0:55
commits can build on each other, and they contain like changes
0:57
to the code as you're improving it. And the proof of work is
1:01
basically doing tons of experimentation to find the
1:03
commits that work. And that's hard. And then the reward is
1:07
just being on the leaderboard right now, there's no monetary
1:10
reward whatsoever. But I don't want to push the analogy too far,
1:13
but it fundamentally has this issue where you run off search
1:16
goes into it, but it's very cheap to verify that a candidate
1:19
solution is indeed good, because you can just train a single,
1:22
you know, someone had to try 10,000 IZs, but you just have to
1:25
check that the thing that they produced actually works,
1:26
because the 99,000 of them didn't work, you know. And so
1:31
basically, long story short, it's like you have to come up with
1:33
a system where an untrusted pool of workers can collaborate
1:37
with a trusted pool of workers that do the verification. And
1:42
the whole thing is kind of like asynchronous and works and
1:44
and so on. And it's like safe from a security perspective,
1:49
because if anyone sends you arbitrary code and you're gonna
1:51
run it, that's very sketchy and dodgy. So, but fundamentally,
1:55
it should be totally possible.
Reply