Following is a script from a presentation by Yann Lecun. The line next to each 
timestamp has the speech he told in that timestamp. 

Note:
When answering question I ask from here, please attach timestamp as the reference 
for claims you make in your response, along with direct quotes made by him to 
ensure factual accuracy.

Question:
According to Lecun, what are the flaws of current LLMs, and what fetures does a 
better future system need?

Transcript:
0:00
- I'm <PRESIDIO_ANONYMIZED_PERSON>, Director of the Center of Mathematical Sciences and Applications here at Harvard.
0:07
This is a center that was founded 10 years ago by S.T. Yau. It's a mathematics center.
0:13
We engage in mathematics and mathematics in interaction two-way interaction with science.
0:19
We have quite a crew of postdocs doing research in mathematics and mathematics, in physics, in economics,
0:27
in computer science and biology. We run some programs, workshops, conferences,
0:33
and a few times a year we have special lectures, and today is one of them.
0:39
This is the fifth annual Ding-Shum lecture. And we're very pleased today to have Yann LeCun,
0:45
who's the chief AI scientist at Meta, and a professor at New York University,
0:52
an expert on machine learning in many, many forms. And today, he'll talk to us about Objective-Driven AI.
1:08
- Thank you very much. Thank you for inviting me, for hosting me. It seems to me like I give a talk at Harvard
1:14
every six months or so, at least for the last few years,
1:20
but to different crowds, physics department, Center for Mathematics,
1:27
psychology, everything.
1:35
So I'm going to talk obviously about AI, but more about the future than about the present.
1:42
And a lot of it is going to be basically, proposals rather than results,
1:48
but preliminary results on the way to go.
1:53
I wrote a paper that I put online about two years ago on what this program is about.
2:00
And you're basically going to hear a little bit of what we have accomplished in the last two years
2:05
towards that program. If you're wondering about the picture here on the right,
2:10
this is my amateurish connection with physics. I take also photography pictures.
2:16
This is taken from my backyard in New Jersey. It's Messier 51, beautiful galaxy.
2:27
Okay, machine learning sucks.
2:32
At least compared to what we observe in humans and animals. It really isn't that good.
2:41
Animals and humans can run new tasks extremely quickly with very few samples or trials.
2:49
They understand how the world works, which is not the case for AI systems today. They can reason and plan, which is not the case
2:54
for AI systems today. They have common sense, which is not the case for AI systems today.
3:00
And the behavior is driven by objective, which is also not the case for most AI systems today.
3:06
Objectives means, you set an objective that you try to accomplish and you kind of plan a sequence of action
3:11
to accomplish this goal. And AI systems like LLMs don't do this at all.
3:18
So the paradigms of learning, supervised learning has been very popular.
3:25
A lot of the success of machine learning at least until fairly recently was mostly with supervised learning.
3:31
Reinforcement learning gave some people a lot of hope, but turned out to be so inefficient
3:36
as to be almost impractical in the real world, at least in isolation, unless you rely much more on something
3:45
called self-supervised learning, which is really what has brought about the big revolution that we've seen in AI
3:50
over the last few years. So the goal of AI really is,
3:59
to build systems that are smart as humans, if not more. And we have systems that are better than humans
4:05
at various tasks today. They're just not very general. So hence people who call human-level intelligence,
4:12
artificial general intelligence, AGI. I hate that term, because human intelligence is actually not general at all,
4:19
it's very specialized. So I think talking about general intelligence,
4:24
but we will mean human-level intelligence is complete nonsense, but that ship has sailed unfortunately.
4:33
But we do need systems that have human-level intelligence, because in a very near future, or not so near future,
4:40
but in the near future, every single one of our interactions with the digital world will be mediated by an AI system.
4:50
We'll have AI systems that are with us at all times. I'm actually wearing smart glasses right now. I can take a picture of you guys.
4:58
Okay, I can click a button or I can say, "Hey, Meta, take a picture,"
5:06
and it takes a picture. Or I can ask you the question,
5:11
and there isn't a LLM that will answer that question. You're not going to hear it, because it's bone conduction, but it's pretty cool.
5:18
So pretty soon we'll have those things and it will be basically the main way that we interact with the digital world.
5:24
Eventually, those systems will have displays which this pair of glasses doesn't have,
5:31
and we'll use those AI systems all the time. The way for them to be non-frustrating
5:39
is for them to be as smart as human assistance, right? So we need human-level intelligence
5:45
just for reasons of basically product design, okay?
5:51
But of course, there's a more kind of interesting scientific question of really what is human intelligence and how can we reproduce it in machines
5:58
and things like that. So it's one of those kind of small number of areas
6:04
where there is people who want a product and are ready to pay for the development of it,
6:11
but at the same time, it's a really great scientific question to work on. And there's not a lot of domains
6:17
where that's the case, right? So, but once we have human-level smart assistant
6:27
that have human-level intelligence, this will amplify humanity's global intelligence,
6:34
if you want. I'll come back on this later. We're very far from that, unfortunately, okay?
6:40
Despite all the hype you hear from Silicon Valley mostly, the people who tell you AGI is just around the corner.
6:47
We're not actually that close. And it's because the systems
6:53
that we have at the moment are extremely limited in some of the capabilities that we have.
7:01
If we had system that approached human intelligence, we would have systems that can learn to drive a car in 20 hours of practice,
7:07
like any 17-year-old. And we do have self-driving cars, but they are heavily engineered, they cheat by using maps,
7:14
using all kinds of expensive sensors, active sensors, and they certainly use a lot more than
7:20
20 hours of training data. So obviously, we're missing something big.
7:25
If we had human-level intelligence, we would have domestic robots that could do simple tasks that a 10-year-old can learn in one shot,
7:32
like clearing up the dinner table and clearing out the dishwasher. And unlike 10-year-olds,
7:38
it wouldn't be difficult to convince them to do it, right?
7:45
But in fact, it's not even humans, just what a cat can do. No AI system at the moment can do in terms of
7:50
planning complex sequences of actions to jump on a piece of furniture or catch a small animal.
8:00
So we're missing something big. And basically, what we're missing is systems
8:07
that are able to learn how the world works, not just from text, but also from let's say video
8:13
or other sensory inputs. Systems that have internal world models,
8:18
systems that have memory, they can reason, they can plan hierarchically like every human and animal.
8:24
So that's the list of requirements, systems that learn world models from sensory inputs,
8:30
learning intuitive physics, for example, which babies learn in the first few months of life. Systems that have persistent memory,
8:37
which current AI systems don't have. Systems that can plan actions,
8:42
so as to fulfillment objectives. And systems that are controllable and safe,
8:48
perhaps through the specification of Guardrail objectives. So this is the idea of objective-driven AI architectures.
8:55
But before I talk about this, I'm going to lay the groundwork for how we can go about that.
9:02
So the first thing is that self-supervised learning has taken over the world. And I first need to explain
9:07
what self-supervised learning is, or perhaps in a special case. But really the success of LLMs and all that stuff,
9:15
and even image recognition these days, and speech recognition translation,
9:21
all the cool stuff in AI, it's really due to self-supervised learning the generalization of the user self-supervised learning.
9:27
So a particular way of doing it is you take a piece of data, let's say a text, you transform it or you corrupt it
9:34
in some way. For a piece of text, that would be replacing some of the words by blank markers, for example.
9:42
And then you train some gigantic neural net to predict the words that are missing, basically, to reconstruct the original input, okay?
9:52
This is how an LLM is trained. It's got a particular architecture, but that only lets the system look at words on the left
10:03
of the word to be predicted. But it's pretty much what it is. And this is a generative architecture,
10:08
because it produces parts of the input, okay?
10:14
There are systems of this type that have been trained to produce images and they use other techniques like diffusion models,
10:22
which I'm not going to go into. I played with one, so Meta has one of course. So you can talk to through WhatsApp and Messenger,
10:30
and there's a paper that describes the system that Meta has built. And I typed the prompt here, up there in that system,
10:39
a photo of a Harvard mathematician proving the Riemann hypothesis on the blackboard
10:44
with the help of an intelligent robot, and that's what it produces.
10:51
I check the proof, it's not correct,
10:57
actually, there's symbols here that I have no idea what they are.
11:04
Okay, so, everybody is excited about generative AI and particular type of it called auto-regressive LLM,
11:15
and really it's train very much like I described. But as I said, the system can only use words
11:22
that are on the left of it to predict a particular word when you train it. So the result is that once the system is trained,
11:29
you can show it a sequence of words and then ask it to produce the next word. Okay, then you can inject that next word into the input.
11:37
You shift the input by one, okay? So the stuff that was produced by the system
11:43
now becomes part of the input and you ask it to produce the second word, shift that in, produce the next, next word,
11:49
shift that in, et cetera, right? So that's called auto-aggressive prediction. It's not a new concept, it's very, very old
11:55
in statistics and signal processing, but in economics actually.
12:00
But that's the way an LLM works. It's auto-aggressive.
12:05
It uses its own prediction as inputs. So those things work amazingly well
12:12
for the simplicity conceptually of how they're trained, which is just predict missing words.
12:18
It's amazing how well they work. Modern ones are trained typically on a few trillion tokens.
12:25
This slide is too old now, it should put a zero. It's not one to 2 trillion, it's more like 20 trillion.
12:31
So a token is a sub-word unit, really, it's on average 3/4 of a word.
12:38
And there is a bunch of those models that have appeared in the last few years. It's not just in the last year and a half
12:45
since ChatGPT came out. That's what made it known to the wider public.
12:50
But those things have been around for quite a while. Things like BlenderBot, Galactica, LlaMA, Llama-2,
12:56
Code Llama, which are produced by FAIR, Mistral and Mixtral from a small French company
13:02
formed by former FAIR people, and then various others Gemma or more recently by Google.
13:08
And then proprietary models, Meta AI, which is built on top of Llama-2,
13:14
and then Gemini from Google, ChatGPT, GPT-4, et cetera.
13:21
And those things make stupid mistakes. They don't really understand logic very well, but if you tell them that A is the same thing as B,
13:28
they don't necessarily know that B is the same as A, for example.
13:33
They don't really understand transitivity of ordering relationships and things like this.
13:39
They don't do logic. You have to sort of explicitly teach them to do arithmetics or have them to call tools to do arithmetics.
13:49
And they don't have any knowledge of the underlying reality. They've only been trained on text. Some of them have been trained also on images,
13:54
but it's basically by treating images like text. So it's very limited,
14:00
but it's very useful to have those things open sourced and available to everyone, because everyone can sort of experiment with them
14:07
and do all kinds of stuff. And there's literally millions of people using Llama
14:13
as a basic platform. So self-supervising is not just used to produce text, but also to do things like translation.
14:19
So there's a system produced by my colleagues a few months ago called SeamlessM4T.
14:25
It can translate 100 languages into a 100 languages.
14:31
And it can do text to text, text to speech, speech to text, and speech to speech. And for speech to speech,
14:37
it can actually translate languages that are not written, which is pretty cool.
14:43
It's also available, you can play with it. It's pretty amazing. I mean, that's kind of superhuman in some way, right?
14:48
I mean, there's few humans that can translate 100 languages into 100 languages in any direction,
14:55
who actually had a previous system that could do 200 languages, but only from text, not from speech.
15:02
But there are dire limitations to the system. The first thing is the auto-aggressive prediction
15:08
is basically, a exponentially divergent process. Every time the system produces a word,
15:14
there is some chance that this word is outside of the set of proper answers.
15:19
And there is no way to come back to correct mistakes, right? So the probability that a sequence of words
15:26
will be kind of a correct answer to the question decreases exponentially with the length of the answer,
15:32
which is not a good thing. And there's various kind of technical papers on this, not by me, that tend to show this.
15:41
A lot of criticism also on the fact that those systems can't really plan. So the amount of computation that an LLM devotes
15:49
to producing a token is fixed, right? You give it a prompt, it runs through however many layers it has in the architecture
15:56
and then produces a token. So per token, the amount of computation is fixed. The only way to get a system
16:02
to think more about something is to trick it into producing more tokens, which is kind of a very kind of circuitous way
16:08
of getting you to do work. And so there's been a quite a bit of research
16:15
on the question of whether those systems are actually capable of planning, and the answer is no, they really can't plan.
16:22
Whenever they can plan or produce a plan. It's basically, because they've been trained on a very similar situation and they already saw a plan
16:30
and they basically regurgitate a very similar plan, but they can't really use tools in new ways, right?
16:40
And then there is the last limitation, which is that they're trained on language. And so they only know whatever knowledge
16:47
is contained in language. And this may sound surprising, but most of human knowledge
16:52
actually has nothing to do with language. So they can be used for as writing assistance,
17:00
giving you ideas if you have the white page's anxiety or something like this.
17:06
They're not good so far for producing factual content and consistent answers, although they're kind of being modified for that.
17:17
And we are easily fooled into thinking that they're intelligent, because they're fluent,
17:23
but really they're not that smart. And they really don't understand how the world works.
17:29
So we're still far from human-level AI.
17:34
As I said, most of human and animal knowledge certainly is non-verbal.
17:40
So what are we missing? Again, I'm reusing those examples of learning to drive
17:47
or learning to clear the dinner table. We are going to have human-level AI,
17:53
not before we have domestic robots that can do those things.
17:59
And this is called a Moravec's paradox, the fact that there are things that appear complex for humans like playing chess
18:05
or planning a complex trajectory, and they're fairly simple for computers.
18:13
But then things that we take for granted that we think don't require intelligence, like what a cat can do,
18:19
it's actually fiendishly complicated. And the reason might be this,
18:24
so it might be the fact that
18:30
the data bandwidth of text is actually very low, right? So a 10 trillion token dataset
18:38
is basically, the totality of the publicly available text
18:43
on the internet, that's about 10 to the 13 bytes, or 10 to the 13 tokens, I should say.
18:49
A token is typically two bytes. There's about 30,000 possible tokens in a typical language.
18:55
So that's 2 to 10 of the 13 bytes for training in LLM.
19:00
It would take 170,000 years for a human to read at eight hours a day, 250 words per minute
19:07
or 100,000 years, if you read fast and you read 12 hours a day.
19:13
Now consider a human child, a 4-year-old child, a 4-year-old child has been awake 16,000 hours at least,
19:20
that's what psychologists are telling us, which by the way is only 30 minutes of YouTube uploads.
19:30
We have 2 million optical nerve fibers going into our visual cortex, about a million from each eye.
19:37
Each fiber maybe carries about 10 bytes per second. Jaim is going, "What?"
19:44
This is an upper bound. And so the data volume that a 4-year-old has seen
19:50
through vision is probably on the order of 10 to 15 bytes.
19:56
That's way more than the totality of all the texts publicly available on the internet.
20:01
50 times more, 50 times more data by the time you're four that you're seen through vision.
20:08
So that tells you a number of things, but the first thing it tells you is that we're never going to get to human-level AI
20:14
by just training on language, it's just not happening. There's just too much background knowledge about the world that we get from observing the world
20:21
that current AI systems don't get.
20:28
So that leads me to this idea of objective-driven AI system.
20:34
What is it that sort of makes humans, for example, capable of, or animals for that matter,
20:39
capable of kind of using tools and objects and situations in new ways and sort of invent new ways of behaving?
20:51
So I wrote a fairly readable, fairly long paper on this.
20:58
You see the URL here, it's not on archive, because it's on this open review site, which you can comment,
21:03
tell me how wrong this is and everything.
21:08
And the basic architecture is kind of shown here.
21:14
So every time you have an arrow, that means there is signals going through, but also means there might be gradients going backwards.
21:21
So I'm assuming everything in there is differentiable. And there is a perception module
21:26
that observes the world, turn it into representations of the world, a memory that might be sort of persistent memory,
21:35
factual memory, things like that. A world model, which is really the centerpiece of this system, an actor and a cost module objective functions.
21:44
The configurator, I'm not going to talk about, at least not for now. So here is how this system works. A typical episode is that the system observes the world,
21:53
feed this through this perception system. Perception system produces some idea of the current state of the world,
22:00
or at least the part of the world that is observable currently. Maybe it can combine this with the content of a memory
22:07
that contains the rest of the state of the world that has been previously observed. Okay, so you get some pretty good idea
22:12
where the current state of the world is. And then the world model, the role of the world model is to take into account the current state of the world
22:19
and hypothesized sequence of actions and to produce a prediction
22:27
as to what is going to be the future state of the world resulting from taking those actions, okay?
22:34
So state of the world at time, t, sequence of actions, state of the world at time, t plus, whatever.
22:42
Now that outcome, that predicted state of the world goes into a number of modules,
22:51
whose role is to compute basically a scalar objective. So each of those square boxes here,
22:57
the red square boxes or pink ones, they're basically scalar-valued function that take representation of the state of the world
23:05
and tell you how far the state of the world is from a particular goal,
23:10
objective target, whatever it is. Or it takes a sequence of predicted states
23:17
and it tells you to what extent that sequence of state is dangerous, toxic, whatever it is, right?
23:23
So those are the guardrail objectives. Okay, so an episode now consists in what the system will do.
23:33
The way it operates, the way it produces its output is going to be an action sequence,
23:39
is going to be by optimizing the objectives,
23:44
the red boxes, whatever comes out of the red boxes with respect to the action sequence, right?
23:50
So there's going to be an optimization process that is going to look for search for
23:55
an action sequence in such a way that the predicted outcome end state of the world
24:01
satisfies the objectives, okay? So this is intrinsically very different principle
24:08
from just running through a bunch of layers in the neural net. This is intrinsically more powerful, right?
24:13
You can express pretty much any algorithmic problem in terms of an optimization problem.
24:19
And this is basically an optimization problem. And not specifying here exactly
24:24
what optimization algorithm to use. If the action sequence space in the space
24:29
in which we do this inference is continuous, we can use gradient-based methods, because all of those modules are differentiable.
24:36
So we can back propagate gradients through the backwards through those arrows and then update the action sequence
24:43
to minimize the objectives and then converge to an optimal action sequence
24:48
for the objective we're looking for, according to a word model.
24:54
If a word model is something like discrete time differential equation or something like this,
25:00
we might have to run it from multiple steps. Okay, so the initial world sequence
25:06
is fed to the world model together with an initial action that predicts the next state.
25:11
From that next state, we feed another action that predicts the next, next state. The entire sequence can be fed to the guardrail objectives,
25:19
and then the end result is fed to the task objective, essentially.
25:27
So this is sort of a ideal situation where the world model is deterministic,
25:36
'cause the world might be deterministic, is very little uncertainty about what's going to happen
25:42
if I do a sequence of action to grab this bottle,
25:47
I'm in control. But most of the world is not completely predictable. So you probably need some sort of latent variable
25:52
that you feed to your world model that would account for all the things you don't know about the world.
25:58
You might have to sample those latent variables within a distribution to make multiple predictions
26:03
about what might happen in the future, because of uncertainties in the world.
26:09
Really, what you want to do ultimately, is not this type of kind of one level planning, but you want to do hierarchical planning.
26:16
So basically, have a system that can produce multiple representations of the state of the world,
26:21
have multiple level of abstraction, so that you can make predictions more or less longterm in the future.
26:28
So here's an example. Let's say I'm sitting in my office at NYU in New York
26:35
and I want to go to Paris. I'm not going to plan my entire trip from New York to Paris
26:42
in terms of millisecond by millisecond muscle control. It's impossible.
26:47
It would be intractable in terms of optimization, obviously, but also it's impossible, because I don't know the condition that will occur.
26:55
Do I have to avoid a particular obstacle that I haven't seen yet? Is a street light going to be red or green?
27:03
How long am I going to wait to grab a taxi? Whatever. So I can't plan everything from the start,
27:12
but what I can do is I can do high level planning, so high level planning at a very abstract level,
27:18
I know that I need to get to the airport and catch a plane. Those are two macro actions, right?
27:24
So that determines a sub-goal for the lower level. How do I get to the airport?
27:30
Well, I'm in New York, so I need to go down in the street and have the taxi. That sets a goal for the level below.
27:38
How do I get to the street where I get, I have to, take the elevator down and then work out on the street?
27:45
How do I go to the elevator? I need to stand up for my chair, open the door in my office, walk to the elevator, push the button.
27:51
How do I get up from my chair? And that I can't describe,
27:57
because it's like muscle control and everything, right? So you can imagine that there is this hierarchical planning thing going on.
28:03
We do this completely effortlessly, absolutely all the time animals do this very well. No AI system today is capable of doing this.
28:13
Some robotic system do hierarchical planning, but it's hardwired, it's handcrafted, right?
28:20
So if you want to have a working robot, walk from here to the door, stairs,
28:28
you first have a high level planning of the trajectory, you're not going to walk directly through here, you're going to have to go through the stairs, et cetera.
28:35
And then at the lower level, you're going to plan the motion of the legs to kind of follow that trajectory. But that's kind of handcrafted.
28:42
It's not like the system has learned to do this. It was kind of built by hand.
28:47
So how do we get systems to spontaneously learn the appropriate levels of abstractions
28:53
to represent action plans? And we really don't know how to do this,
28:58
or at least we don't have any demonstration of any system that does this, that actually works.
29:05
Okay, so next question is going to be, if we're going to build a system of this type, is how are we going to build a world model?
29:13
Again, world model is state of the world at time, t action, predicted state of the world at time, t plus 1,
29:22
whatever the unit of time is. And the question is, how do humans do this or animals?
29:30
So you look at what age babies learn basic concepts. They sold this chart from Emmanuel Dupoux,
29:36
who's a psychologist in Paris. And the basic things like basic object categories
29:43
and things like this that are learned pretty early on without language, right? Babies don't really understand language at the age
29:49
of four months, but they develop the notion of object categories spontaneously,
29:56
things like solidity, rigidity of object, a difference between animate and inanimate objects.
30:01
And then intuitive physics pops up around nine months. So it takes about nine months for babies to learn that objects that are not supported,
30:08
fall because of gravity, and more concepts in intuitive physics.
30:13
It is not fast, right? I mean, we take a long time to learn this. Most of this, at least in the first few months of life
30:20
is learned mostly by observation, who has very little interaction with the world, 'cause a baby until, three, four months
30:27
can't really kind of manipulate anything or affect the world beyond their limbs.
30:32
So most of what they learn about the world is mostly observation. And the question is, what type of learning is taking place
30:38
when babies do this? This is what we need to reproduce.
30:43
So there is a natural idea which is to just transpose the idea of self-supervised training for text and use it for video, let's say, right?
30:49
So, take a video, call this y, full video and then corrupt it by masking a piece of it,
30:57
let's say the second half of the video. So call this masked video x,
31:03
and then train some gigantic neural net to predict the part of the video that is missing. And hoping that if the system predicts
31:12
what's going to happen in the video, probably has good idea of what the underlying nature of the physical world is.
31:18
A very natural concept. In fact, neuroscientists have been thinking about this kind of stuff for a very long time. It's called predictive coding.
31:24
And I mean this idea that you learn by prediction is really very standard.
31:30
You do this and it doesn't work. We've tried for, my colleague and I
31:36
have been trying to do this for 10 years, and you don't get good representations of the world,
31:43
you don't get good predictions. The kind of prediction you get are very blurry,
31:48
kind of like the video at the top here where the first four frames of that video are observed,
31:55
the last two are predicted by neural net and it predicts very blurry images. The reason being that it can't really predict
32:02
what's going to happen, so it predicts the average of all the plausible things that may happen. And that's a very blurry video.
32:09
So doesn't work. The solution to this is to basically abandon the idea
32:15
of generative models. That might seem shocking given that this is
32:20
the most popular thing in machine learning at the moment. But we're going to have to do that.
32:25
And the solution is that I'm proposing at least, is to replace this by something I call
32:33
joint embedding predictive architectures, JEPA. This is what a JEPA is.
32:39
So you take y, you corrupt it, same story or you transform it in some way.
32:45
But instead of reconstructing y from x, you run both x and y through encoders.
32:51
And what you reconstruct is you reconstruct the representation of y from the representation of x.
32:57
So you're not trying to predict every pixel, you're only trying to predict a representation
33:03
of the input which may not contain all the information about the input,
33:08
may contain only partial information. So that's the difference between those two architectures.
33:15
On the left, generative architectures that reproduce y,
33:20
on the right, joint embedding architectures that embed x and y into a representation space.
33:27
And you do the prediction in representation space. And there's various flavors of this joint embedding architecture.
33:37
The one on the left is an old idea called Siamese networks, goes back to the early nineties I worked on.
33:45
And then there is deterministic and non-deterministic versions of those JEPA architectures. I'm not going to go into the details.
33:53
The reason why you might need latent variables in the predictor, is because it could be that
33:59
the world is intrinsically unpredictable or not fully observable or stochastic.
34:05
And so you need some sort of way of making multiple predictions for a single observation, right?
34:10
So the z variable here is basically parametizes the set of things you don't know about the world
34:17
that you have not observed in the state of the world. And that will parametize the set of potential predictions.
34:24
Now there's another variable here called a, and that's what turns the joint embedding architecture
34:29
into a world model. This is a world model, okay? x is an observation,
34:38
sx is the representation of that observation. a would be an action that you take.
34:44
And then sy is a prediction of the representation of the state of the world after you've taken the action, okay?
34:53
And the way you train the system is by minimizing the prediction error. So y would be the future observation
34:58
of the world, right? x is the past and the present,
35:03
y is the future. You just have to wait a little bit before you observe it. You make a prediction, you take an action
35:10
or you observe someone taking an action, you make a prediction about what the state, the future state of the world is going to be.
35:15
And then you can compare the actual state of the world that you observe with the predicted state
35:22
and then train the system to minimize the prediction error. But there's an issue with this,
35:27
which is that that system can collapse. If you only minimize the prediction error, what it can do is ignore x and y completely,
35:35
produce sx and sy that are constant and then the prediction problem becomes trivial. So you cannot train a system of this type
35:42
by just minimizing the prediction error. You have to be a little smarter about how you do it.
35:48
And to understand how this works, you have to basically use a concept called energy-based models,
35:53
which is, you can think of as a weakened version of probabilistic modeling.
36:02
And for the physicists in the room,
36:07
the way to turn to go from energies to probabilities is you take exponential minus and normalize.
36:12
But if you manipulate the energy function directly, you don't need this normalization. So that's the advantage. So what is an energy-based model?
36:18
It's basically, an implicit function F of x,y that measures the degree of incompatibility between x and y.
36:27
Whether y is a good continuation for x in the case of video, whether y is a good set of missing words from x,
36:34
things like that, right? But basically, that function takes the two argument x and y
36:39
and gives you a scalar value that indicates to what extent x and y are compatible or incompatible.
36:45
It gives you zero if x and y are compatible or a small value
36:50
and it gives you a larger value if they're not. Okay, so imagine that those two variables as scalar
36:57
and the observations are the black dots.
37:03
That's your training data, essentially. You want to train this energy function in such a way that it takes low values
37:10
on the training data and around, and then higher value everywhere else.
37:16
And what I've represented here is kind of the lines of equal energy if you want
37:24
the contours of equal energy. So how are we going to do this? So, okay, so the energy function is not a function
37:32
you minimized by training, it's a function you minimized by inference, right? If I want to find a y that is compatible with an x,
37:41
I search over the space of ys for a value of y that minimizes F of x,y, okay? So the inference process does not consist
37:49
in running feet forward through a neural net. It consists in minimizing an energy function
37:54
with respect to y. And this is computationally, this is intrinsically more powerful than running through a fixed number of layers
38:01
in the neural net. So that gets around the limitation of auto-aggressive LLMs that spanned a fixed amount of computation per token.
38:09
This way of doing inference can span in a limited amount of resources
38:17
figuring out a good y that minimizes F of x,y depending on the nature of F and the nature of y.
38:25
So if y is a continuous variable and your function hopefully is differentiable, you can minimize it using gradient-based methods.
38:33
If it's not, if it's discreet, then will have to do some sort of combinatorial search, but that would be way less efficient.
38:38
So if you can make everything continuous and differentiable, you're much better off.
38:47
And by the way, I meant, I forgot to mention something when I talked about world model, this idea that you have a world model
38:52
that can predict what's going to happen as a consequence of a sequence of actions, and then you have an objective you want to minimize
38:58
and you plan a sequence of action that minimize the objective. This is completely classical optimal control.
39:04
It's called model predictive control. It's been around since the early sixties if not the late fifties.
39:10
And so it's completely standard. The main difference with what we want to do here
39:16
is that the world model is going to be learned from sensory data as opposed to kind of a bunch of equations
39:21
you're going to write down for the dynamics of a rocket or something. Here we're just going to learn it from sensory data, right?
39:28
Okay, so there's two methods really to train those energy functions,
39:34
so that they take the right shape. Okay, so now we're going to talk about learning how do you shape the energy surface in such a way
39:40
that it gives you low energy on the data points and high energy outside? And these two classes of methods
39:45
to prevent this collapse I was telling you about. So the collapse is situation where you just minimize the energy
39:51
for whatever training samples you have. And what you get in the end is an energy function that is zero everywhere.
39:57
That's not a good model. You want an energy function that takes low energy on the data points
40:02
and high energy outside. So two methods. Contrastive methods consist in generating
40:08
those green flashing points, contrastive samples and pushing their energy up, okay?
40:14
So back propagate gradient through the entire system, so that, and tweak the parameters, so that the output energy goes up for a green point
40:22
and then so that it goes down for a blue point, a data point. But those tend to be inefficient in high dimensions.
40:28
So I'm more in favor of another set of methods called regularized methods, that basically work by minimizing the volume of space
40:35
that can take low energy, so that when you push down the energy of a particular region, it has to go up in other places,
40:41
because there is only a limited amount of low energy stuff to go around.
40:48
So those are two classes of method are going to argue for the regularized methods. But really you should think about two classes of method
40:55
to train energy-based models. And when I say energy-based models, this also applies to probabilistic models,
41:02
which are essentially a special case of energy-based models.
41:09
Okay, there's a particular type of energy-based model which are called latent variable models. And they consist in either in sort of models
41:17
that have a latent variable z that is not given to you during training or during tests that you have to infer the value of.
41:23
And you can do this by either minimizing the energy with respect to z. So if you have an energy function E of x,y,z,
41:29
you minimize it with respect to z, and then you put that z into the energy function and the resulting function does not depend on z anymore.
41:36
And I call this F of x,y, right? So having latent variable models is really kind of a very simple thing in many ways.
41:46
If you are a Bayesian or probabilist, instead of inferring a single value for z, you infer a distribution.
41:53
But I might talk about this later a little bit. So depending on which architecture you're going to use
41:58
for your system, it may or may not collapse. And so, if it can collapse,
42:04
then you have to use one of those objective functions that prevent collapse either through contrastive training
42:10
or through regularization. If you're a physicist,
42:15
you probably already know that it's very easy to turn energies into probability distributions.
42:22
You compute P of y given x, if you know the energy of x and y, you do exponential minus some constant F of x,y
42:29
and then you normalize by the integral over all the space of y, of the numerator.
42:34
So you get a normalized distribution of a y and that's a perfectly fine way of parameterizing a distribution if you really want.
42:41
The problem of course, in a lot of statistical physics is that the denominator
42:46
called the partition function is intractable. And so here I'm basically just circumventing the problem
42:54
by directly manipulating the energy function and not worrying about the normalization.
43:01
But basically, this idea of pushing down, pushing up the energy, minimizing the volume of stuff
43:06
that can take low energy, that plays the same role of what would be normalization in a probabilistic model.
43:15
I'm not going to go through this, it's in our chart, you can take a picture if you want. This is basically a list of all kinds of classical methods
43:22
as to whether they're contrastive or regularized. All of them can be interpreted as some sort of energy-based model
43:28
that is either one or the other.
43:35
And the idea that is used in LLM, which is basically a particular version of something called denoising auto-encoder
43:41
is a contrastive method. So the way we train LLMs today
43:46
is contrastive, okay? We take a piece of data, we corrupt it and we train the system to reconstruct
43:53
the missing information. That's actually a special case of something called a denoising auto-encoder, which is very old idea
44:00
that's been revived multiple times since then.
44:09
And this framework can allow us to interpret a lot of classical models like K-means, sparse coding,
44:15
things like that. But I don't want to spend too much time on this. You can do probabilistic inference,
44:21
but I want to skip this. This is for these free energies and variational free energies and stuff like that.
44:28
But here's the recommendations I'm making, abandon generative models in favor of those joint embedding architectures,
44:34
abandon probabilistic modeling in favor of this energy-based models, abandon contrastive methods in favor of those regularized methods.
44:41
And I'm going to describe one in a minute and also abandon reinforcement learning, but I've been seeing this for 10 years.
44:48
So they are four most popular things in machine learning today, which doesn't make me very popular.
45:00
So how do you train a JEPA with regularized methods?
45:05
So there's a number of different methods, I'm going to describe two classes. One for which we really understand why it works
45:10
and the other one it works, but we don't understand why, but it works really well. So the first class of method
45:16
consists in basically preventing this collapse I was telling you about where the output of the encoder is constant
45:24
or carries very little information about the input. So what we're going to do is have a criterion during training
45:30
that tries to maximize the amount of information coming out of the encoders to prevent this collapse.
45:37
And the bad news with this is that to maximize the information content coming out of a neural net,
45:42
we would need some sort of lower bound on information content of the output and then push up on it, right?
45:49
The bad news is that we don't have lower bounds on information content, we only have upper bounds.
45:54
So we're going to need to cross our fingers, take an upper bound on information content, push it up,
45:59
and hope that the actual information content follows.
46:04
And it kind of works, it actually works really well, but it's not well-justified theoretically for that reason.
46:13
How do we do this? So first thing we can do is make sure that the variables that come out of the encoders
46:21
are not constant. So over a batch of samples, you want each variable
46:26
of the output vector of the encoder to have some non-zero variance, let's say one, okay?
46:31
So you have a cost function that says I really want the variance to be larger than one or standard deviation.
46:38
Okay, still the system can produce a non-informative output by making all the outputs equal or highly correlated.
46:45
Okay, so you have a second criterion that says, in addition to this, I want the different components
46:51
of the output vector to be uncorrelated. So basically, I want a criterion that says I want to bring the covariance matrix
46:57
of the vectors coming out of the encoder as close to the identity matrix as possible,
47:04
but still is not enough, because you will get uncorrelated variables but it still could be very dependent.
47:10
So there's another trick which consists in taking the representation vector sx and running it through a neural net
47:15
that expands the dimension in a nonlinear way and then decorrelate those variables
47:21
and we can show that under certain conditions this actually has the effect of making pairs of variables independent.
47:27
Okay, not just uncorrelated. So a paper on this
47:35
here on archive. Okay, so now we have a way of training one of those
47:40
joint embedding architectures to prevent collapse. And it's really a regularized method. We don't need to have contrastive samples,
47:46
we don't need to kind of pull things away from each other or anything like that. We just train it on training samples.
47:53
And we have this criterion. Once we've trained that system, we can use the representation learned by the system,
48:01
sorry, the representation learned by the system sx, and then feed this to a subsequent classifier
48:08
that we can train supervised for a particular task. For example, object recognition, right?
48:14
So we can train a linear classifier or something more sophisticated and I'm not going to bore you with the result,
48:21
but every role here is a different way of doing self-supervised learning. Some of them are generative,
48:26
some of them are joint embedding. They use different types of criteria, different types of distortions and corruption
48:33
for the images. And the top systems, give you 70% correct on ImageNet,
48:39
when you train only the head on ImageNet, you don't fine-tune the entire network, you just use the features.
48:47
And what's interesting about self-supervised learning is that those systems work really well.
48:52
They don't require a lot of data to basically learn a new task. So it's really good for transfer learning
48:58
or multitask learning or whatever it is. You learn generic features and then you use them as input to kind of a subsequent task,
49:06
with sort of variations of this idea. So this method is called VICReg and that means variance, in variance, covariance, regularization.
49:14
Variance, covariance, because of this covariance matrix criterion. In variance, because we want the representation
49:21
of the corrupted and uncorrupted inputs to be identical.
49:26
With versions of this that work for object detection and localization and stuff like that. But there is another set of methods
49:33
and those, I have to admit that I don't completely understand why they work.
49:39
These people like Yonglong Tian at FAIR and Surya Ganguli at Stanford who claim they understand
49:45
they'll have to explain this to me, because I'm not entirely convinced. And those are distillation methods.
49:50
So you have two encoders, they have to be more or less identical in terms of architectures. Actually exactly identical,
49:55
they need to have the same parameters. And you share the parameters between them. So there is something called weight EMA.
50:02
EMA means exponential moving average. So the encoder on the right gets weights that are basically a running average
50:11
with exponential decaying coefficient of the weight vectors produced by the encoder on the left
50:17
as learning takes place. So it's kind of a smoothed-out version of the weights.
50:24
And Surya and Yonglong have explanations why this prevent the system from collapsing.
50:32
Encourage you to read that paper if you can figure it out. And there's a number of different methods
50:38
that are using this self-supervised pre-training to work really well.
50:46
Old methods like Bootstrap Your Own Latents from DeepMind SimSiam by FAIR, and then DINOv2, which is 1-year-old method
50:54
by colleagues at FAIR in Paris, which is probably the best system that produces generic features for images.
51:00
If you have a vision problem, you need some generic features to be fed to some classifiers. So you can train it with a small amount of data,
51:07
use in DINOv2. Today, that's the best thing we have. And it produces really nice features,
51:14
really good performance with very small amounts of data for all kinds of things. You can train it to do segmentation,
51:21
to do depth estimation, to do object recognition, to estimate the height of the tree canopy,
51:29
on the entire earth, to detect tumors in chest x-rays,
51:36
all kinds of stuff. That is open source, so a lot of people have been using it for all kinds of stuff. It's really cool.
51:43
A particular instantiation of those distillation method is something called I-JEPA.
51:48
So this is a JEPA architecture that has been trained using this distillation method, but it's different from DINOv.
51:56
And this works extremely well, in fact, better than DINOv for the same amount of training
52:04
and it's very fast to train as well. So this is the best method we have
52:09
and it compares very favorably to competing methods that use generative models that are trained by reconstruction.
52:17
So there's something called MAE mask auto-encoder and which are the hollow squares here on this graph.
52:27
Maybe I should show this one. So this is a method also developed at Meta at FAIR,
52:32
but it works by reconstructing a photo, right? So you take a photo, you mask some parts of it
52:39
and you train what amounts to auto-encoder to reconstruct the parts that are missing.
52:45
And it's very difficult to predict what's missing in an image, because you can have complicated textures
52:51
and stuff like that. And in fact, this system is much more expensive to train
52:56
and it doesn't work as well as this joint embedding methods, right? So the one lesson from this talk is
53:03
generative method for images are bad, they're good for text but not too good for images. Whereas joint embedding methods are good for images,
53:11
not yet good for text. And the reason is images
53:17
are high-dimensional and continuous. So generating them is actually hard.
53:23
It's possible to produce image generation system that produce nice images but they're not good, they don't produce good
53:29
internal representations of images.
53:35
On the other hand, generating models for text works, because text is discreet.
53:40
So language is simple, because it's discreet, essentially. Where this idea that language is kind of the most sophisticated stuff,
53:46
because only humans can do it. In fact, it's simple. The real world is really what's hard.
53:53
So I-JEPA works really well for all kinds of tasks and people have used this for all kind of stuff.
54:00
There's some mathematics to do here, which I'm going to have to skip.
54:05
To talk about V-JEPA. So this is a version of I-JEPA but for video
54:10
that was put online fairly recently. And there the idea is you take a piece of video,
54:16
you mask part of it and again you train one of those joint embedding architectures to basically predict the representation
54:25
of the full video from the representation of the partially masked or corrupted video.
54:31
And this works really well in the sense that
54:41
when you take the representation learned by that system, you feed it to a classifier to basically classify the action
54:48
that is taking place in the video. You get really good performance and you get better performance than any other
54:53
self-supervised learning technique. When you have a lot of training data, it doesn't work as well as purely supervised
55:00
with all kinds of tricks and data augmentation, but it comes really close
55:05
and it doesn't require labeled data or not much. So that's kind of a big breakthrough a little bit.
55:13
The fact that we can train system to learn from video in self-supervised manner, because now we can might be able to use this
55:19
to learn world models, right? Where the masking of the video is,
55:26
we take a video mask the second half of it and ask the system to predict what's going to happen, feeding it an action that is being taken in the video.
55:34
If you have that, you have a world model. If you have a world model, you can put it in a planning system. If you can have a system that can plan,
55:40
then you might have systems that are a lot smarter than current systems and they might be able to plan actions,
55:47
not just words. They're not going to predict auto-aggressively anymore.
55:54
They're going to plan their answer kind of like what we do, like we speak, we don't produce one word after the other without thinking.
56:01
We usually kind of plan what we're going to say in advance, at least some of us do.
56:14
So this works really well in the sense that we get really good performance on lots of different types of video
56:20
for classifying the action and various other tasks, better than basically anything else
56:25
that people have tried before. Certainly better than any system that has been trained on video. And this, the pre-training here
56:31
is on a relatively small amount of video actually, it's not a huge dataset, this is speed.
56:38
So this is reconstructions of missing parts of a video
56:44
by that system and it's done by training a separate decoder, right? So it's not part of the initial training,
56:49
but in the end we can use the representation as input to a decoder that we trained to reconstruct the part of the image that's missing.
56:55
And these are the result of completing basically the entire middle of the image is missing
57:02
and the system is kind of filling in things that are reasonable. It's a cooking video and there's a hand
57:10
and knife and some ingredients. Okay, it is another topic I want to talk about,
57:17
because I know there are mathematicians and physicists in the room. This is a recent paper, a collaboration between
57:24
some of us at FAIR and Bobak Kiani,
57:30
who is a student at MIT with Seth Lloyd and a bunch of people from MIT. So this system is basically using this idea
57:39
of joint embedding to learn something about partial differential equations that we observe through a solution.
57:46
So look at the thing at the bottom. We have a PDE, Burgers' equation.
57:52
What you see are diagrams of space time diagrams basically, of a solution of that PDE.
58:00
And what we're going to do is we're going to take two windows, separate windows on the solution of that PDE, okay?
58:08
And of course, the solution depends on the initial condition. You're going to get different solutions for different initial conditions, right?
58:13
So we're going to take two windows over two different solutions to that PDE, and we're going to do a joint embedding.
58:20
So we're going to train an encoder to produce representations, so that the representation can be predicted,
58:26
the representation for one piece of the solution can be predicted from a representation from the other piece.
58:34
And what the system ends up doing in that case is basically predict or represent
58:39
the coefficient of the equation that is being sold, right? The only thing that's common between one region
58:47
of the space, time solution of PDE and another region, is that it's the same equation with the same coefficient.
58:54
What's different is the initial condition. But the equation itself is the same, right? So the system basically discovers some representation
59:02
and when we train now a supervised system to predict the coefficient of the equation,
59:08
it actually does a really good job. In fact it does a better job than if we train it completely supervised from scratch.
59:15
So that's really interesting, these very tricks in this thing for transformations of the solution
59:24
according to in variance properties of the equation, which I'm not going to go into, but that's using the VICReg procedure I described earlier.
59:35
So we applied this to a bunch of different PDEs Kuramoto-Sivashinsky
59:41
where we try to kind of identify some of the coefficients in the equation.
59:48
Navier-Stokes, we try to identify the buoyancy parameter
59:53
in Navier-Stokes, which is a constant term at the end. And this works better again than just training a supervised system
1:00:00
to predict what the buoyancy is from observing the behavior.
1:00:05
So this is pretty cool. I mean there's already papers that have kind of recycled this idea in other context.
1:00:12
Okay, so that's end of the technical part. For the conclusion, we have a lot of problems to solve,
1:00:19
some of which are mathematical, like the mathematical foundations of energy-based learning I think are not completely worked out.
1:00:25
The idea that the dependency between sets of variables is represented by an energy function
1:00:31
that takes low energy on the data manifold and high energy outside, it's a very general idea. It breaks the whole kind of hypothesis
1:00:38
of probabilistic modeling. And I think we need to understand better, what are the properties of such things?
1:00:45
We need to work on JEPA architectures that have regularized rating variables. I didn't talk much about this, but that's kind of a necessity.
1:00:52
Planning algorithms in the presence of uncertainty, hopefully using reading-based methods,
1:00:58
learning cost modules to guarantee safety, for example,
1:01:03
planning in the presence of inaccuracies of the world model. If your world model is wrong,
1:01:08
you're going to plan wrong sequences of actions, because you're not going to predict the right outcomes. So how you deal with that?
1:01:15
And then exploration mechanisms to adjust the world model for regions of the space where the system is not very good.
1:01:23
So we're working on self-supervised learning from video, as I told you.
1:01:28
Evidence that can reason and plan driven by objectives. So according to the objective-driven architecture I showed,
1:01:35
but for text as well as for robotic control. And then trying to figure out if we can do this
1:01:43
sort of hierarchical planning idea I was telling you about earlier.
1:01:48
Let's see. So in this future where every one of our interactions are mediated
1:01:55
by AI systems, what that means is that AI systems will essentially constitute a repository
1:02:02
of all human knowledge, and that everyone will use,
1:02:07
sort of like a Wikipedia you can talk to and possibly knows more than Wikipedia.
1:02:15
Every one of those systems is necessarily biased, okay? Is trained by on data
1:02:20
that is available on the internet. There's more data in English than in any other language.
1:02:26
There's a lot of language for research is very little data. So those systems are going to be biased necessarily.
1:02:34
And we've seen pretty dramatic examples recently with the Jenny system from Google,
1:02:40
where the bias really was like, so they spent so much effort to kind of make sure
1:02:45
the system was not biased, that it was biased in a other obnoxious way.
1:02:53
And so bias is inevitable. And it's the same as in the media and the press.
1:03:00
Every journal, every news magazine newspaper is biased. The way we fix this is we have a high diversity
1:03:09
of very different magazines and newspapers. We don't get our information from a single system.
1:03:16
We have a choice between various bias systems, basically. This is what is going to have to happen for AI as well.
1:03:25
We're not going to have unbiased AI systems. So the solution is to have lots and lots of bias systems,
1:03:31
bias for your language, your culture, your value system, your centers of interest, whatever it is.
1:03:37
So what we need is a very simple platform that allows basically anyone to fine-tune
1:03:43
an open source AI system, open source LLM for their own language culture,
1:03:49
value system, centers of interest. Basically, a weekly but not a weekly
1:03:55
where you write articles, a weekly where you fine-tune a LLM.
1:04:01
That's the future of AI that I see, that I want to see, a future in which all of our interaction are mediated
1:04:08
by AI systems that are produced by three companies on the west coast of the U.S. is not a good future,
1:04:16
and I work for one of those companies, but I'm happy to say that Meta
1:04:24
has completely bought this idea that AI platforms need to be open and is committed to open sourcing
1:04:33
the various incarnations of Llama. The next one being Llama-3 coming soon.
1:04:40
So open source AI platforms are necessary. They're necessary for even the preservation of democracy
1:04:46
for the same reason that diversity of the press is necessary for democracy.
1:04:54
So one big danger is that open source AI platforms will be regulated out of existence,
1:05:00
because of the fact that some people think AI is dangerous. And so they say you can't put AI in the hands of everyone.
1:05:07
It's too dangerous. You need to regulate it. And that will kill AI, open source AI platforms.
1:05:14
I think that's much more dangerous. The dangers of this are much, much higher than the dangers of putting AI in the hands of everybody.
1:05:23
And how long is it going to take for us to reach human-level AI with AI systems?
1:05:30
It's not going to be next year, like LLM says, or LLM says before the end of the year, it's BS.
1:05:39
It's not going to be next year. Despite what you might hear from open AI. It's probably not going to be in the next five years.
1:05:46
It's going to take a while before the program I described here
1:05:51
works to the level that we want. And it's not going to be an event. It's not going to be AI achieved internally or anything.
1:06:01
It's not going to be like an event with all of a sudden we discovered the secret to AGI and all of a sudden we have super-intelligent system.
1:06:07
It's not going to happen that way. We're going to build systems of the type I describe and make them bigger and bigger
1:06:13
and learn them more and more stuff, put more and more guardrails and objectives and stuff like that and walk our way out so that
1:06:19
as they become smarter and smarter, they also become more secure and safe and well-behaved
1:06:25
and everything, right? So it's not going to be an event, it's going to be progressive
1:06:32
motion towards more and more powerful and more safe AI systems.
1:06:39
And we need contributions from everyone, which is why we need open source models.
1:06:44
And I'll stop here. Thank you very much.
1:06:57
- Thank you for a wonderful thought-provoking talk. We have time for a few questions.
1:07:06
- [Audience Member] Hello, yeah, I've been trying to figure out why you put encoder in front of y,
1:07:13
because you're getting the representation of the output image and you've been losing information
1:07:21
and does that mean your architecture is as good as your encoder? So I couldn't figure out why you put it that way.
1:07:29
So can you help me to understand? - Sure, I have two answers to this. Are you a physicist by any chance?
1:07:35
- Computer scientist. - Computer scientist, okay? But there are physicists in the room, okay? But this is very basic physics.
1:07:44
If you want to predict the trajectory of planets, most of the information about any planet
1:07:49
is completely relevant to the prediction, right? The shape, the size, the density, the composition,
1:07:58
all of that is completely relevant. The only thing that matters is six variables, which are position and velocities, right?
1:08:04
And you can predict the trajectory. So the big question in making predictions
1:08:12
and planning and stuff like that is what is the appropriate information and the appropriate abstraction level
1:08:19
to make the prediction you want to make? And then everything else eliminate it, because if you spend all of your resources
1:08:26
trying to predict those things that are irrelevant, you are completely wasting your time, right?
1:08:34
So that's the first answer. The second answer is imagine that the video I'm training the system on,
1:08:40
is a video of this room where I point the camera this way and I pan slowly and I stop right before you.
1:08:48
And I ask the system, I predict what's going to happen next in the video. The system will probably predict that the panning is going to continue.
1:08:54
There's going to be people sitting, and at some point there's going to be a wall. There's absolutely no way it can predict what we look like
1:09:01
or what anybody will look like. No way it's going to predict how many steps
1:09:07
there are in the stairs. No way it's going to predict the precise texture of the wall or the carpet, right?
1:09:16
So there's all kinds of details here that are completely unpredictable, yet if you train a generative system to predict why,
1:09:23
it's going to have to actually devote a lot of resources to predict those details, right? So the whole question of the machine learning,
1:09:31
and to some extent science is what is the appropriate representation that allows you to make predictions that are useful, right?
1:09:38
So JEPA gives you that, generating models don't.
1:09:46
- [Morris] Hello, my name is Morris and I'm a PhD student at MIT and I noticed that you're a JEPA architecture looks a lot like
1:09:52
the common filter, you have a sequence of measurements, and even when you want a common filter,
1:09:58
there is often a problem, which is that you need a condition called observability and you have a very clever way
1:10:04
of getting around this condition of observability, because in your latent space, you can come up with a clever regularize
1:10:10
for the things that you cannot see. Does the world model help in coming up with these regularizes?
1:10:16
And secondly, your control would probably come in on the latent state.
1:10:22
Is that how you think it would work out in the end? Or I mean, I yeah, that's my question.
1:10:27
- Yeah, okay. Actually, it's not like a common filter.
1:10:33
A common filter, the encoders are reversed, they're not encoders, they're decoders.
1:10:40
So I'm looking for the general picture here of where I had the world model.
1:10:48
Yeah, this one is probably the best. Okay, so in a common filter,
1:10:55
first of all, you get a sequence of observation and here, the observation goes into an encoder
1:11:03
that produces the estimate of the state. In a common filter is actually the other way around. You have a hypothesized state
1:11:09
and you run into a decoder that produces the observation. And what you do is you invert. - From the measurements.
1:11:19
- Right, right, I mean you're learning a hidden dynamics. So in that sense it's similar,
1:11:27
but then you are generating the observation from the hidden states, right? So it's a bit reverse.
1:11:33
And then there is a constraint in, at least in traditional camera filters
1:11:39
where the dynamics are linear. Then there is extended camera filters where it's non-linear,
1:11:44
and then a particular provision to handle the uncertainties. So you assume Gaussian distributions of everything basically, right?
1:11:51
But yeah, there is a connection, because there is a connection with optimal control and common filters are kind of the thing in optimal control.
1:12:05
- [Audience Member] Hi, so I have a bit of a less technical question, but given that you're also a citizen of France
1:12:11
and broadly the EU, and given all what you said about sort of having the open models and sort of potentially
1:12:18
one of the main problems for these systems being sort of regulatory capture or legislative problems, what do you think about the new EU AI Act
1:12:25
and does that kind of influence you think or might influence how Europe is going to proceed
1:12:30
with kind of R&D and AI development and potentially Meta's presence in France?
1:12:36
- Well, so there, there are good things and bad things in the EU AI Act. The good things are things like, okay,
1:12:43
you can't use AI to give a social score to people, that's a good idea.
1:12:48
You can't put cameras that do face recognition in public spaces unless there is special conditions
1:12:55
the Paris Olympic games or whatever. So, I mean, those are good things
1:13:00
for privacy protection and stuff like that. What is less good is that at the last minute
1:13:07
there were discussions where they started putting provisions inside of it for what they call frontier models, right?
1:13:14
So, powerful, this is because of ChatGPT, let say if you're a powerful model,
1:13:20
it's potentially dangerous. So we need to regulate research and development, not just regulate products, but regulate research and development.
1:13:27
I think that's completely wrong. I think this is very destructive depending on
1:13:33
how it's applied. I mean, it might be applied in ways that, in the end are benign,
1:13:40
but it could be that they might be kind of a little too tight about it. And what is going to cause is that companies like Meta
1:13:49
are going to say, well, we're not going to open source to Europe, right? We're going to open source the rest of the world,
1:13:56
but if you're from Europe, you can download it. And that would be really, really bad.
1:14:02
Some companies like Australia are probably going to move out. So I think we're the fork in the road
1:14:09
where things could go bad. I mean, there's a similar phenomenon in the U.S. with the executive order of the White House,
1:14:16
where it could go one way or the other depending on how it's applied.
1:14:21
In fact, the NTIA had a request or comment
1:14:28
that Meta us submitted one and said, make sure that you don't legislate open source AI
1:14:34
out of existence, because the reason to do this would be imaginary risks,
1:14:40
existential risks that are really completely crazy, nuts, pardon my French.
1:14:48
But the idea somehow that, all of a sudden you're going to discover the secret to AGI
1:14:54
and super-intelligence system is going to take over the world within minutes
1:14:59
and it's just completely ridiculous. This is not how the world works at all.
1:15:06
But there are people with a lot of money who have funded a lot of think tanks that have lobbied or basically lobbied government
1:15:15
into thinking this. And so governments have organized meetings, they're like, "Are we going to all be dead next year?"
1:15:21
Or stuff like that. So you have to tell them first, we're far away from human-level intelligence, don't believe,
1:15:27
the guys who tell you is it like Elon, that it's just around the corner. And second, we can build them in ways that are non-dangerous
1:15:35
and it's not going to be an event. It's going to be gradual and progressive. And we have ways to build those things in a safe way.
1:15:42
Don't rely on the fact that current LLMs are unreliable and elucidate.
1:15:48
Don't project this to future systems. Future systems will have completely different architecture perhaps of the type that I described.
1:15:55
And that makes them controllable, because you can put guardrails and objectives and everything.
1:16:00
So discussing the existential risk of AI systems today, super-intelligent system today
1:16:08
is insane, because they're not being invented yet. We don't know what they would look like.
1:16:13
It's like discussing the safety of transatlantic flight
1:16:19
on a jet airliner in 1925. The turbo jet was not invented yet,
1:16:27
and it didn't happen in one day, right? It took decades before, now you can fly halfway around the world in complete safety
1:16:34
with a two-engine jet plane. That's amazing, incredibly safe, it took decades.
1:16:42
It's going to be the same thing. - So that's a good place to wrap it up. So let's thank Yann again for a wonderful talk.
1:16:50
- Thank you.