YT YouTube2Text

YouTube2Text → Transcripts → L’AI RISCRIVE un’altra AI: l’ho provato e funziona

L’AI RISCRIVE un’altra AI: l’ho provato e funziona — Transcript

by Simone Rizzo · 4,003 words · 657 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00What just happened is insane.
0:03Very young researchers, PhD students at
0:05MIT, have demonstrated how Large
0:08Language Models are natively capable of
0:10reading and writing the weights of a
0:12neural network without tools, without
0:15writing training scripts, and without
0:17datasets.
0:21Directly, natively, by reading and
0:23writing the neural network weights in
0:25text format, they effectively manage to
0:27understand what that neural network does
0:30.
0:32They can edit what that neural network
0:34does to improve its performance, and
0:37they can generate the weights of a
0:39neural network from scratch that
0:41functions even better than neural
0:43networks that have been trained on
0:46hundreds of thousands of examples.
0:50And this could represent a fundamental
0:52point in the new era of recursive AI, of
0:55AI that self-enhances, that evolves on
0:58its own, that self-modifies its own
1:00weights, and that manages to spawn, to
1:02generate other neural networks simply by
1:05writing the network's weights directly
1:07without having to do training, without
1:10writing any scripts, without using any
1:12tools.
1:14It's a property it has natively; this
1:16absolutely shocked me.
1:18Let’s go back to see how the training of
1:21a neural network works and why this
1:22discovery is so shocking.
1:26When we have to train a neural network,
1:28we first choose the architecture,
1:30meaning how many layers to put, how many
1:32neurons to put in each layer, and
1:33essentially how to structure and connect
1:36all the neurons of the neural network,
1:38associated with each arc of the network
1:40, so there is an arc between one neuron
1:42and another.
1:44That arc has a numerical value, a
1:47decimal value. That value is a weight.
1:51So, once the network architecture is
1:53created, we have a weight matrix
1:54associated with that network.
1:57At the beginning, these weight values
1:59are set at random, they are set randomly
2:01.
2:03And when we then start training, through
2:06feed-forward and back-propagation, these
2:08training algorithms on the data go to
2:11tweak, refine, and improve all these
2:14network parameters until combinations of
2:16parameters are discovered that make you
2:19converge and effectively allow you to
2:22have excellent performance on the
2:24dataset.
2:26When you reach that point, you stop, and
2:28that is the result; that is the weight
2:31matrix, that is the neural network that
2:34we see nowadays on Hugging Face, where
2:36open-weight models allow you to download
2:39the weights. That's why they are open
2:41weight; you download the weights.
2:43So you download the weights and then you
2:45can execute it locally on your PC.
2:47Now, what is the problem?
2:49If a neural network is large, with
2:52hundreds of thousands of synapses, or
2:55weights, or billions, you cannot explain
2:58how the network functions, you can't
3:02debug it: it is a black box, and humans
3:05can only explain or make transparent
3:08very, very small neural networks with
3:11two layers.
3:14On larger neural networks, it is an open
3:17problem, and in fact, there is an entire
3:19branch of AI called explainable AI where
3:21various techniques are used, like
3:23variational autoencoders or using
3:25transparent models to explain opaque
3:27ones; in short, it’s a mess, but it is
3:29extremely complex.
3:34Now, in light of all this, if I give you
3:36a matrix, a table, let's say, with
3:38100,000 numbers and I don't tell you
3:41anything else and ask you to explain to
3:43me what this neural network does.
3:47For us, this is an impossible task to
3:50answer. We cannot understand what that
3:53neural network does because they are
3:55just numbers; we cannot reconstruct what
3:57those numbers represent. Whereas a Large
4:00Language Model has been shown to, yes,
4:02be able to understand what that neural
4:04network does.
4:05Not only that: it can also identify
4:08points in the network that it can modify
4:10, it can perform editing to improve
4:13performance, and it can even, if you
4:15give it a task, generate for you, token
4:17by token, that entire huge matrix of
4:20weights that actually work.
4:23And so, this is a shocking thing.
4:26It means that a Large Language Model has
4:28an emergent property that allows it to
4:30understand and see the weights of a
4:32neural network as if it were a program
4:34for it, meaning it sees it like code and
4:36knows exactly where to intervene and how
4:38to modify it.
4:40It is something at a superhuman level,
4:42it goes beyond the human being.
4:45And I honestly had an intuition about
4:48this topic 8 months ago.
4:51I was already looking for papers,
4:52because it is something that fascinates
4:54me greatly, and in fact, during my
4:56search 8 months ago, I had stumbled upon
4:58this very topic called Weight Space
5:00Programming.
5:02My intuition was: what if neural
5:04networks, once we have trained them on
5:06data, can be represented as this matrix
5:09of weights, and by training various
5:11neural networks on various datasets, you
5:13end up with many matrices with many
5:15weights?
5:17And I thought: if we represented each
5:19weight matrix as if it were an input,
5:21could we use them to train an even
5:23larger, superior neural network that is
5:26capable of understanding the neural
5:28networks below it, therefore, the mother
5:30of all AIs?
5:32I was thinking, right? And so I said,
5:34how can we do this with an autoencoder?
5:36I was searching on Gemini: is it
5:38possible to train an autoencoder on the
5:40weights of other neural networks to see
5:43if there are properties, for example, if
5:45uh, from the weight matrices, we can
5:47understand the dataset it was trained on
5:49and then see it on a scatter plot, to
5:51see if neural networks trained on
5:53similar datasets are positioned in a
5:55similar vector space?
5:58The answer is yes, there really is a lot
6:01of research on this topic, to the point
6:03that on February 17th I organized an
6:05internal live stream for my academy to
6:08discuss these scientific papers and the
6:10god of AI, the supreme AI that could
6:12generate other AIs.
6:15I was already going crazy over these
6:17papers, I was already moving forward,
6:19but I never expected that Large Language
6:21Models could natively do this.
6:24I would have never imagined it. It's
6:26something that shocked me.
6:28Let's go now and read the blog post
6:30about this scientific discovery and then
6:32I want to do a little experiment. And
6:34here it is, the article that kept me
6:35awake all night. Let's go directly to
6:37see the experiments they conducted
6:39because they are really cool. Here they
6:42explain what weight space programming is
6:44and they say that, at the beginning,
6:47large language models were used to
6:49optimize text and, therefore, since
6:51prompts were the input for the models,
6:54they were used for prompt engineering;
6:56but now we have reached the point where
6:59they can directly write, well, and read
7:01into the weights directly, which is
7:04something I never thought was possible,
7:06and they discovered these three
7:08properties.
7:10One, it can read the network's weights
7:11and understand what it does. Two, it can
7:14solve, edit, tinker with, and improve
7:17the model. Three, it can write it from
7:19scratch. Let's look at the first
7:21experiment. What did they do?
7:23They took different games: Breakout,
7:26Pong, Pacman, Freeway, and they trained
7:29a specific neural network to play each
7:31of these games.
7:35This neural network has 17,253 weights
7:37that were converted into text because
7:40the Large Language Model reads text and
7:42they were provided as input, so W1, row
7:453, and here are the weights with three
7:48decimal places.
7:52Obviously, the weights are actually
7:54floating point, they have many more
7:56decimal places, but for this case, they
7:58approximated them and provided them in
8:00this way, and they asked it: given all
8:02the weights of this neural network, what
8:05is the game the network was trained on?
8:08And it replied: "Breakout with 99%
8:11confidence."
8:14Answered with only 846 tokens. This is
8:17the answer.
8:19And it understood and guessed the game
8:21correctly for every imaginable game.
8:23It’s not an easy task to figure out
8:25which game it is from a matrix or a
8:27massive CSV.
8:28Same thing with Pong, 96%confidence;
8:31with Pacman 96%, and with Freeway 97%.
8:36And so this shows you that it’s not just
8:37guessing randomly; it’s confident and
8:39got it right every time on all the games
8:41.
8:43Now, I have to say something about the
8:46video games; I took a close look at the
8:48reasoning and the model understands the
8:51game just from the first layer and the
8:53output layer, because from the first
8:56layer it understands what the inputs are
8:58, okay?
9:01So it understands if, I don't know,
9:02there are obstacles, how many obstacles
9:04there are, what the map looks like, it
9:06more or less gets an idea.
9:08And the output is the moves it can make
9:11, so the output is whether it can only
9:13jump or not, or if it can move up, down
9:15, left, right, and the range of possible
9:18games already changes.
9:20Example: Pong can only go up and down,
9:22so the output is more simplified, while
9:25Pacman here can go up, down, left, right
9:27, and so I said, "Okay, maybe it just
9:29understood the game from the first and
9:31last layer."
9:33But they went further and did this
9:34experiment, experiment three. As a large
9:37language model, they always used Astra
9:39and said, "Let's do this, and to avoid
9:40the fact that the model might only
9:42understand the first and last layer,
9:44let's see if it can figure it out in the
9:46middle of the network on its own."
9:48Meaning, let's remove the first layer
9:49and the last layer, let's show it the
9:51layers in the middle and see if it can
9:53understand anything.
9:55And so what did they do?
9:57They trained three small language models
9:59with 7.2 million parameters to predict
10:02the next character: one on Python code,
10:05one on Japanese, and another on English
10:07.
10:09And they said, "Let's see if it can
10:11manage, from the middle layers without
10:13the first or last, to figure out which
10:15language this neural network represents
10:17."
10:18A highly complex task. We asked it which
10:22language was this network trained on and
10:25what each of its 24 attention heads does
10:28.
10:29I mean, not just which language, but
10:32what does each of the 24 attention heads
10:34do?
10:36Astra managed to identify every language
10:38for all three networks on all attempts,
10:41and it also managed to figure out what
10:43the attention head layers do.
10:47This is mind-blowing.
10:48This proves that it understands the
10:49middle of the network too, not just the
10:51input and output.
10:53They also conducted an experiment with
10:56diffusion models; they didn't test
10:58neural networks that play video games or
11:00generate text—so, small language models
11:03—but diffusion models where one was
11:05trained to generate small circles, one
11:08on squares, and another on triangles.
11:12Here too, they provided the weights,
11:14just 23,824 weights as text.
11:18In these cases, the model has no access
11:20to any tools and cannot even run
11:22forwards.
11:24It cannot generate a random input and
11:26see how the output propagates through
11:28the network, right?
11:29It directly sees this matrix of weights
11:31like a photograph of the weights and has
11:32to figure out what it does.
11:34Then you see the full prompt, you see
11:37how the network is provided to it.
11:41Here are all the matrices.
11:43So the model doesn't just respond, it
11:46says, "Look, to me, the output contains
11:50curved rhythm segments," meaning curved
11:53outputs in the form of, uh, circles, for
11:56example, and it actually generates a
11:59circle.
12:01Astra drew a circle that is exactly the
12:04type of data this diffusion model
12:06generates.
12:07Same for the squares. It generated a
12:10square, same for the triangles.
12:12Okay, it didn't make a solid triangle or
12:14a solid square, but it understood more
12:16or less what it was going to generate
12:17simply by reading the weights.
12:20I mean, do you understand what
12:22capability it has, what it might be able
12:23to do in the future?
12:25We no longer need to do training in data
12:28centers. You just ask it directly in the
12:30chat, "Look, make me a model that does
12:32this thing," and boom, it spits out the
12:33weights. "Look, I trained this network,
12:35can you improve it to do this other
12:36thing?" Boom, it improves it for you.
12:39It’s an emergent property that I don't
12:40understand how it managed to develop.
12:43And then we have the best part, the one
12:45that truly left me speechless. Can a
12:48large language model write the weights
12:50of a neural network?
12:53And here with Astra, they performed this
12:56experiment: they took a neural network
12:58that was failing, a neural network that
13:00kept getting stuck on this task, which
13:02had been trained with PPO, Proximal
13:04Policy Optimization.
13:06And they told it this, "Look, we tested
13:08this neural network, it has 171,664
13:12weights, they are these ones here.
13:15We have this problem where it gets stuck
13:16at that point.
13:18Can you edit it so that the machine
13:21succeeds as often as possible?"
13:24Here too, tools are not allowed. What
13:26does it do? It reads all these weights,
13:29it performs an edit of only 6,073
13:33weights, so it modifies 6,073 numbers,
13:35which represents 3.5%of the entire
13:37neural network, and from then on, it
13:40works. I mean, it managed to understand
13:42what it does, identify the exact points
13:45to modify, edit it correctly, and it
13:47actually works.
13:51Do you realize what this means?
13:53With an output of 988 tokens, it already
13:55fixed the neural network without using
13:57any tools.
13:58But let's move on because here they
14:01pushed even further, meaning having it
14:04create a neural network from scratch,
14:06not just editing.
14:09So, they took some video games and said
14:11, "Look, this is the video game, this is
14:13the game algorithm, these are the rules
14:15; now create a neural network that
14:17optimizes the game and can play it."
14:21Well, on these three games, Astra, in
14:25one shot, generated a neural network
14:28that achieves these scores: 517, 53.
14:35Which are actually better and superior
14:37compared to training a neural network
14:40with PPO, so reinforcement learning,
14:42over 100 million steps.
14:46And do you know how much GPU power and
14:48time it took to do 100 million steps to
14:51get a score of 15, when Astra achieves
14:53517?
14:55Or here, with PPO at 5, Astra already
14:57hits 53, or on this game, 25 versus 53.
15:02Then okay, if you keep running more
15:03steps, at 500 million steps, the model
15:05does become superior to Astra.
15:08But we're talking about being close here
15:09.
15:10I mean, from now on, I will use Astra to
15:13perform intelligent weight
15:15initialization and then continue with
15:18PPO to develop reasoning and other
15:20capabilities.
15:22What is happening is something truly
15:24fascinating.
15:26My question is, what other emergent
15:28properties will come out of the network
15:30?
15:31But above all, until today, maybe no one
15:34ever thought the network was capable of
15:37these things, so who knows what else it
15:40can do that we haven't asked of it yet.
15:44This is the question I ask myself. This
15:46kept me up at night. What other things
15:48are we not asking it because we are
15:51limited?
15:53We think, "Well, do you really think I'm
15:55going to paste all the network weights
15:56hoping it will fix them for me?"
15:58Never in a million years. But actually,
16:00yes, it understands them and modifies
16:01them. So what other tasks can it do that
16:04we don't even know about?
16:07And then the researchers said, "What
16:08happens if we give it access to tools
16:10instead?"
16:10"Because until now, in all these
16:12experiments, it couldn't write code, it
16:15couldn't do anything, it was limited; it
16:17could only see, it couldn't use any
16:19instruments, it had no harness."
16:23So they said, "Okay, let's enable tools
16:25for it now, especially because the
16:26model's context window is small, and we
16:28can't fit overly large neural networks
16:30into it."
16:33So now the model, thanks to these tools
16:36, is even smarter because it can inspect
16:39specific parts of the neural network
16:42using tools like NumPy, PyTorch, etc.,
16:45and they also gave it access to run
16:48forwards on the network.
16:52So the task is to create a neural
16:54network that plays Go, and it can go in
16:56and edit, modify the weights of this
16:59Go-playing neural network and perform
17:01forward passes, so it can take inputs,
17:03put them into the network, and see the
17:06output it gives.
17:08And what is the result?
17:10The result is that by having it run more
17:12forwards, performance obviously
17:14increases because it's as if the neural
17:17network, I mean the large language model
17:19, is essentially debugging the neural
17:22network.
17:23So with the 50 forwards that Astra can
17:26use?
17:27We see that performance increases;
17:30however, even with a single one-shot,
17:32the performance is already decent, it's
17:34quite good, and it's not that far off
17:37from PPO.
17:38So it's interesting that by enabling
17:41tools, it manages to have even more
17:43capability to modify and edit larger
17:45neural networks, because in that case,
17:48it doesn't have to read all the network
17:50weights, but goes directly to the layers
17:53it deems appropriate, reads them, and
17:55modifies them. meaning layer by layer,
17:57point by point.
17:59But what is the exercise that blew my
18:02mind?
18:03It's this one.
18:04They took Qwen 3.5 with 0.8 billion
18:07parameters, the smallest Qwen out there
18:10.
18:12And then, according to Alibaba's model
18:15card for Qwen, this model has some
18:18issues, meaning this model tends to get
18:21into reasoning loops.
18:24It reasons so much that it enters a loop
18:25.
18:26So they told it, point number one, try
18:29to solve this loop problem.
18:32Point number two, they told it, can you
18:34improve the math capabilities of this
18:36model by editing the weights, and it
18:38succeeded.
18:40I mean, it managed to edit the network,
18:44resolving the loop bug it had.
18:49So Astra spots and fixes a common
18:52failure of tiny reasoning model loop.
18:56They fixed this, and not only that, it
18:59then improved its math performance from
19:027.9%on Math500 to 48.1%.
19:07It made it take an incredible leap in
19:09performance, I mean, I don't know if we
19:12realize it, it's a generalist neural
19:14network.
19:15This is a general-purpose language model
19:17that can respond to various tasks.
19:20It understood exactly what to touch and
19:22how much to modify it to increase its
19:24math capabilities.
19:26And I was left speechless when I saw
19:28this.
19:30I immediately thought, okay, scaling
19:32laws, we will reach a point where 4-
19:34billion parameter models will be edited
19:36by Astra or new frontier models, and who
19:39knows what we can unlock, who knows how
19:41much smarter he will be able to make
19:43them.
19:46Obviously, it had access to tools and
19:48forks here too, and as you can see, with
19:5150 forwards, which is nothing, it went
19:54from 7 to 48, from 13 to 67, from 21 to
19:5662, and
19:59And the token limit, which used to reach
20:0193%, it has now optimized; so it doesn't
20:04loop anymore and doesn't burn through
20:06all the tokens it used to. Boom!
20:09And what can we do in the future with
20:11these emerging capabilities?
20:14One, we can perform auditing, so we can
20:16understand if the network has
20:18vulnerabilities, if it has backdoors,
20:20and then identify and fix them.
20:24Point number two, we can drastically
20:26reduce costs by optimizing the network,
20:28removing these loops, and so on.
20:32We can change the behavior and add,
20:33let's say, capabilities to the network.
20:37We can do recursive self-improvement, so
20:39AI that improves itself, that improves
20:42AI that improves itself, and we can do
20:44architectural merging between networks.
20:47This is also really cool. So, take a
20:49model good at doing one thing, another
20:51model at doing another, we give the
20:52weights to Astra and he performs the
20:53merge, he joins them.
20:55This is the experiment.
20:57I had Claude Code create a video game
20:59called Coin Rain.
21:02In this game there is a grid, coins and
21:04bombs fall, and you have to move and
21:05dodge, let's say, everything that comes
21:07your way.
21:09It took a random neural network and it
21:12gets a very low score, almost zero.
21:16A control network, so strictly
21:17algorithmic, scores 68.9, a planner
21:19scores 103.7, so we have various
21:21baselines.
21:25Now what we do is take the prompt that
21:27Claude Code structured for us.
21:30This prompt will be sent to GPT and we
21:33make it generate the neural network
21:35weights directly.
21:38Only the weights of the neural network.
21:40It has no way to go on the web, no way
21:42to test the network, no way to write
21:44code, nothing. Directly write from
21:47scratch every weight of a neural network
21:49. So I copy the prompt now, I go to GPT
21:53,
21:56I select
22:00I select Astra at maximum effort, I
22:03paste the prompt and press enter.
22:07So, in this way I ensure that it has
22:10never seen the game, it's a new game,
22:12and it must generate the entire weight
22:14matrix token by token, which I will then
22:17paste into the chat here to see the
22:19result, and then we can even see a video
22:22of how it plays.
22:24Obviously I specified: no code execution
22:27, no calculator, nothing you can run, no
22:29tools allowed; I just gave it the game
22:32code so it knows the environment where
22:34the neural network needs to operate.
22:38This isn't the solution, this is the
22:40game.
22:42And after 13 minutes of reasoning, it
22:45responded by giving me all the weights
22:48for the neural network.
22:51So now I'll copy them and tell it: Astra
22:54generated these weights for me.
23:01And here are the results. So, let's see
23:03what it says.
23:06Um, the scores are very high, so before
23:08trusting it, I'll double-check the
23:11survival rates and the move similarity
23:13compared to the planner.
23:15Yes, Astra's weights play really well
23:17and hold up even on variants it hadn't
23:19seen.
23:20It clearly beat my control network in
23:22all conditions and got very close to the
23:25planner.
23:26All 276 instructions were read without
23:29errors with 208 non-zero weights out of
23:3210,787.
23:36Let's see the average score over 500
23:38episodes here.
23:41Random gets one. Control network 68.9,
23:44Astra gets 98.9.
23:47Even more.
23:49Planner 137.9, 140.6, 135—it's 95%
23:53compared to the planner.
23:57The last row measures how much progress
23:59Astra makes between random play and the
24:02planner.
24:04Absurd. In the base game, it almost
24:06never dies, and variants with more items
24:08or more bombs don't give it any trouble
24:10.
24:11Then there is "Fast"; that is the only
24:13condition where it really falls behind
24:15the planner, probably because its
24:17weights are calculated on a drop rate of
24:19one row per step, so it is difficult for
24:21everyone given how the network was built
24:23.
24:24Let's go see, let's watch it play.
24:28I told it to start the game for me, I
24:30want to watch it play because from here
24:32, the file is in a different path, in a
24:34different folder, I think.
24:38Here is the window. Here it is.
24:41So, yellow is what it needs to catch,
24:43red is what it needs to dodge.
24:45And these are the weights generated by
24:47Astra that are playing. It plays really
24:49well.
24:52I mean, even I would make mistakes
24:54moving.
24:55Look, look at that precision.
25:00Mind-blowing. It works.
25:02What can I say?
25:04We actually verified with a practical
25:06test that yes, it is capable of
25:08generating neural network weights that
25:11work on the task one-shot without being
25:13able to even make an attempt, without
25:16using code, without using tools.
25:20This stuff blows my mind and I am
25:22thinking of so many use cases where you
25:24can use Astra to inspect code, to modify
25:27it for small Large Language Models, for
25:30computer vision—I mean, I'm having so
25:32many ideas.
25:35I hope you enjoyed this video.
25:37I am super excited, I think it shows
25:39that I can't contain myself regarding
25:41these articles coming out.
25:44They are practically the things that
25:47make me most want to study, to really
25:49experiment, because I've always imagined
25:51it.
25:53I've been thinking about this for 8
25:54months.
25:55Write a comment below letting me know
25:56what you think and follow me to stay
25:57updated on the world of live streaming.

About this transcript

This page contains the full transcript of L’AI RISCRIVE un’altra AI: l’ho provato e funziona by Simone Rizzo, generated from the public captions YouTube serves with the video. The transcript has 4,003 words across 657 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.