This is a talk by Stephen Wolfram for MIT course 6.S099: Artificial General Intelligence. This class is free and open to everyone. Our goal is to take an engineering approach to exploring possible paths toward building human-level intelligence for a better world.

INFO:
Course website: https://agi.mit.edu
AI podcast: https://lexfridman.com/ai

CONNECT:
- If you enjoyed this video, please subscribe to this channel.
- AI Podcast: https://lexfridman.com/ai/
- Show your support: https://www.patreon.com/lexfridman
- LinkedIn: https://www.linkedin.com/in/lexfridman
- Twitter: https://twitter.com/lexfridman
- Facebook: https://www.facebook.com/lexfridman
- Instagram: https://www.instagram.com/lexfridman

Welcome back to 6S099 Artificial General Intelligence.

I didn't even get started, you're already clapping.

In his book, A New Kind of Science, he has explored and revealed the power, beauty, and complexity of cellular automata as simple computational systems for which incredible complexity can emerge.

It's actually 1 of the books that really inspired me to get into artificial intelligence.

He's created the Wolfram Alpha computational knowledge engine, created Mathematica that has now expanded to become Wolfram Language.

Both he and his son were involved in helping analyze, create the alien language from the movie Arrival, of which they use the Wolfram language.

Please, again, give Stephen a warm welcome.

All right, so I gather the brief here is to talk about how artificial general intelligence is going to be achieved.

So maybe I'm reminded of kind of a story which I don't think I've ever told in public, but that something that happened just a few buildings over from here.

So this was 2009, and Wolfram Alpha was about to arrive on the scene.

I assume most of you have used Wolfram Alpha or seen Wolfram Alpha, yes?

So I had long been a friend of Marvin Minsky's, and Marvin was a sort of pioneer of the AI world.

And I'd kind of seen for years, you know, question answering systems that tried to do sort of general intelligence question answering.

And so I was gonna show Marvin, you know, Wolfram Alpha, he looks at it, he's like, oh, okay, that's fine, whatever.

Said, no, Marvin, this time it actually works.

It took about 5 minutes for Marvin to realize that this was finally a question answering system that could actually answer questions that were useful to people.

And so 1 question is how did we achieve that?

So you go to Wolfram Alpha and you can ask it,

I mean it's, I don't know what we can ask it, I don't know, what's the, some Random question, what is the population of Cambridge?

Actually, here's a question, divided by, let's try that.

If we mean Cambridge, Massachusetts, it's gonna give us some number, it's gonna give us some plot.

Actually, what I wanna know is number of students at MIT divided by population of Cambridge.

Oh no, that's divided by, ah, That's interesting.

It guessed that we were talking about Cambridge University as the denominator there.

So it says the number of students at MIT divided by the number

That's interesting, I'm actually surprised.

Let's see what happens if I say Cambridge MA there.

That's a plot as a function of time, of the fraction of the, okay, so anyway.

So 1 question is how did we manage to get, so many things have to work in order to get stuff like this to work.

You have to be able to understand the natural language, you have to have data sources, you have to be able to compute things from the data and so on.

1 of the things that was a surprise to me was in terms of natural language understanding was the critical thing turned out to be just knowing a lot of stuff.

The actual parsing of the natural language is kind of,

we use a bunch of ideas that came from my new kind of science project and so on.

But I think the most important thing is just knowing a lot of stuff about the world is really important to actually being able to understand natural language in a useful situation.

I think the other thing is having, actually having access to lots of data.

a typical example here of what is needed.

So I ask about the ISS, and hopefully it'll wake up and tell us something here, come on, what's going on here?

So it figured out that we probably are talking about a spacecraft, not

a file format, and now it's gonna give us a plot that shows us where the ISS is right now.

So to make this work, we obviously have to have some feed of radar tracking data about satellites and so on, which we have for every satellite that's out there.

But then that's not good enough to just have that feed.

Then you also have to be able to do celestial mechanics to work out, well, where is the ISS actually right now based on the orbital elements that have been deduced from radar?

And then if we want to know things like, okay, when is it going to, it's not currently visible from Boston, Massachusetts, it will next rise at 7.36 p.m.

So this requires a mixture of data about what's going on in the world together with models about how the world is supposed to work, being able to predict things and so on.

And I think another thing that I kind of realized about AI and so on from the Wolfram Alpha effort has been that 1 of the earlier ideas for how 1 would achieve AI was let's make it work kind of like brains do and let's make it figure stuff out.

And so if it has to do physics, let's have it do physics by pure reasoning, like people at least used to do physics.

But in the last 300 years, we've had a different way to do physics that wasn't sort of based on natural philosophy.

It was instead based on things like mathematics.

And so 1 of the things that we were doing in Wolfram Alpha was to kind of cheat relative to what had been done in previous AI systems, which was instead of using kind of reasoning type methods, we're just saying, okay, we want to compute where the ISS is going to be, well, we've got a bunch of equations of motion that correspond to differential equations, we're just gonna solve the equations of motion and get an answer.

That's kind of leveraging the last 300 years or so of exact science that have been done rather than trying to make use of kind of human reasoning ideas.

And I might say that in terms of the history of the Wolfram Alpha project, when I was a kid a disgustingly long time ago, I was interested in AI kinds of things, and I, in fact, I was kind of upset recently to find a bunch of stuff I did when I was 12 years old, kind of trying to assemble a pre-version of Wolfram Alpha way back before it was technologically possible, but it's also a reminder that 1 just does the same thing one's whole life, so

But what happened was when I started off working mainly in physics and then I got involved in building computer systems to do things like mathematical computation and so on.

And I then sort of got interested in, okay, so can we generalize this stuff and can we really make systems that can answer sort of arbitrary questions about the world, and for example, sort of the promise would be if there's something that is systematically known in our civilization, make it automatic to answer questions on the basis of that systematic knowledge.

And back in around late 1970s, early 1980s, my conclusion was if you want to do something like that, the only realistic path to being able to do it was to build something much like a brain.

And so I got interested in neural nets and I tried to do things with neural nets back in 1980 and nothing very interesting happened.

Well, I couldn't get them to do anything very interesting.

And that, so I kind of had the idea that the only way to get the kind of thing that now exists in Wolfram Alpha, for example, was to build a brain-like thing.

And then many years later, for reasons I can explain, I kind of came back to this and realized actually it wasn't true that you had to build a brain-like thing, sort of mere computation was sufficient.

And that was kind of what got me started actually trying to build WolfMalpha.

When we started building WolfMalpha, 1 of the things I did was go to a sort of a field trip to a big reference library, and you see all these shelves of books and so on, and the question is, can we take all of this knowledge that exists in all of these books and actually automate being able to answer questions on the basis of it and I think we've pretty much done that for that at least the books you find in a typical reference library.

So that was it looked kind of daunting at the beginning because it's just there's a lot of knowledge and information out there but actually it turns out there are a few thousand domains and we've steadily gone through and worked on these different domains.

Another feature of the Wolfram Alpha project was that we didn't really, you know, I'd been involved a lot in doing basic science and in trying to have sort of grand theories of the world.

1 of my principles in building Wolfram Alpha was not to start from a grand theory of the world.

That is, not to kind of start from some global ontology of the world and then try and build down into all these different domains, but instead to work up from having hundreds then thousands of domains that actually work, whether they're information about cars or information about sports or information about movies or whatever else, have each of these domains sort of building up from the bottom in each of these domains and then finding that there were common themes in these domains that we could then build into frameworks and then sort of construct the whole system on the basis of that.

And I can talk about some of the actual frameworks that we end up using and so on.

But maybe I should explain a little bit more.

So 1 question is how does WolframAlpha actually sort of work inside?

It's about, it's the core system is about 15 million lines of Wolfram language code, and it's some number of terabytes of raw data.

And so the way, the thing that sort of made building Wolfram Alpha possible was this language, Wolfram Language, which started with Mathematica, which came out in 1988, and has been sort of progressively growing since then.

So maybe I should show you some things about Wolfram Language and and you know, it's easy.

Let's start off with something like, let's make a random graph.

And let's say we have a random graph with 200 nodes, 400 vertices.

The first important thing about Wolfram Language is that it's a symbolic language.

So I can just pick up this graph and I could say, you know, I don't want to do some analysis of this graph.

That graph is just a symbolic thing that I can just do computations on.

Oh, I could say, let's get a, another good thing to always do is get a current image.

And now I could go and say something like, let's do some basic thing.

Again, this image is just a thing that we can manipulate.

take the image and partition it into little pieces, do computations on that.

I don't know, simple, let's do, let's just say, sort each row of the image, assemble the image again.

Assemble that image again, we'll get some mixed up picture there.

If I wanted to, I could for example, let's say, let's make that the current image, and let's say make that dynamic.

I can be just running that code, hopefully, and a little loop, and there we can make that work.

So 1 general point here is, this is just an image for us, it's just a piece of data like anything else.

If we just have a variable, a thing called x, it just says, okay, that's x, I don't need to know a particular value, It's just a symbolic thing that corresponds to That's a thing called X now, you know what gets interesting when you have Symbolic language and so on is we're interested in having it represent stuff about the world as well as just abstract kinds of things.

I mean, you know, I can abstractly say, you know, find some funky integral, I don't know what, you know, that's then representing, using symbolic variables to represent algebraic kinds of things, but I could also just say, I don't know, something like Boston.

And Boston is another kind of symbolic thing that has, if I say, what is it really inside?

That's, it's the entity, a city, Boston, Massachusetts, United States.

Actually, you notice when I typed that in, I was using natural language to type it in and it gave me a bunch of disambiguation here.

It said, assuming Boston is a city, assuming Boston, Massachusetts, use Boston, New York, or okay, there's let's use let's use Boston in the Philippines, which I've never heard of but but Let's try using that instead and now if I look at that it'll say it's Boston in some province of the Philippines, etc etc, etc.

Now I might ask it of that, I could say something like, what's the population of that?

Or I could say, for example, let me do this.

Let me say a geolist plot from that Boston, let's take from that Boston to, and now let's type in Boston again, and now let's have it use the default meaning of the word of Boston, and then let's join those up, and now this should plot, this should show me a plot.

So there's the path from the Boston that we picked in the Philippines to the Boston here.

don't know, I could just say, I could ask it the distance from

So the 1 of the things here, 1 of the things we found really, really useful actually in Wolfen language, so first of all there's a way of representing stuff about the world like cities for example.

Well let's say I want to say, let's do this, let's say,

let's do something with cities, let's say capital cities in South America.

Okay, so notice this is a piece of natural language.

This will get interpreted into something which is precise symbolic Wolffian language code that we can then compute with and that will give us the capital cities in South America.

I could, for example, let's say I say find shortest tour.

What I want to do first is to say, show me the geopositions of all those cities on line 21 there so now it will find the geopositions and now it will say, compute the shortest tour.

a 10,000 mile traveling salesman tour around those cities.

So I could take those cities, we're on line 21, and I could say, order the cities according to this, and then I could make another geolist plot of that, join it up, And this should now show us a traveling salesman tour of the capital cities in South America.

So, it's sort of interesting to see what's involved in making stuff like this work.

1 of, my goal has been to sort of automate as much as possible about things that have to be computed and that means knowing as many algorithms as possible and also knowing as much data about the world as possible.

And I kind of view this as sort of a knowledge-based programming approach where you have a typical kind of idea in programming languages is, you have some small programming languages has a few primitives that are pretty much tied in to what a machine can intrinsically do, and then maybe you'll have libraries that add on to that and so on.

My kind of crazy idea of many, many years ago has been to build an integrated system where all of the stuff about different domains of knowledge and so on are all just built into the system and designed in a coherent way.

I mean, this has been kind of the story of my life for the last 30 years, is trying to keep the design of the system coherent, even as 1 adds all sorts of different areas

we can go and dive into all sorts of different kinds of things here, but maybe as an example, well, let's do, what could we do here?

We could take come let's try How about this?

So this will now use a completely different domain of Human Endeavor.

Let's just try them Let's try left Humerus, let's try the the that the mesh region for that and now we should have a bone here okay there's a there's a representation of a bone let's take that bone and we could for example say let's take the surface area of that as in some Some units or

I could let's do some much more outrageous thing.

Let's say we take Region distance, so we're going to take the distance from some from that bone to

a point Let's say 00Z and let's make a plot of that distance with Z going from Let's say I have no idea where that where this bone is, but let's try something like this.

Let's try So what this is doing again a whole bunch of stuff has to work in order for this to operate.

This has to be, this is a, this is some region in 3D space that's represented by some mesh.

You have to compute, you know, do the computational geometry to figure out where it is.

If I wanted to, let's try anatomy anatomy plot 3D and let's say something like left hand for example, and now it's going to show us probably the complete data that it has about the geometry of

there's there's the result and we could take that apart and start computing things from it and so

so there's a lot of kind of computational knowledge that's built in here.

1, let's talk a little bit about kind of the modern machine learning story.

So for instance, if I say, let's get a picture here.

Let's say, let's just say picture of, has anybody got a favorite kind of animal?

Let's see what, now let's try saying, let's try for this panda, let's try saying image identify.

And now here we'll be embarrassed probably, but let's just see.

Let's see what happens if I say image identify that.

And now it'll hopefully, wake up, wake up, wake up.

This only takes a few hundred milliseconds.

Let's see what the runners up were to the giant panda.

Let's say we want to say the 10 runners up in all categories for that thing.

Okay, So a giant panda, a procyonid, which I've never heard of.

So that was so lucky it didn't get that 1.

It's really sure it's a mammal and it's absolutely certain.

It's a vertebrate Okay, so you might ask how did it figure this out?

And so then you can kind of look under the hood and say So we have a whole framework for representing neural nets symbolically And so this is the actual model that it's using to do this.

So this is a, so there's a neural net and it's got, we can drill down and we can see there's a piece of the neural net, we can drill down even further to 1 of these and we can probably see what, that's a batch normalization layer, somewhere deep, deep inside the entrails of the, not panda, but of this thing, okay?

So now let's take that object, which is just a symbolic object, and let's feed it the picture of the panda and we can see and there oops

Oh here, let's take, oh I see what I did.

Okay, let's take this thing and feed it the picture of the panda and it says a giant panda.

Okay, How about we do something more outrageous?

Let's take that neural net and let's only use the first, let's say, 10 layers of the neural net.

So let's just take out 10 layers of the neural net and feed it the panda.

And now what we'll get is something from the insides of the neural net.

And I could say, for example, let's just make those into images.

Okay, so that's what the neural net had figured out about the panda after 10 layers of going through the neural net and maybe actually be interesting to see, let's do a feature space plot.

So now we're going to, of those intermediate things in the

sort of in the brain of the neural net, so

to speak, this is now taking, so what this is just doing is to do dimension reduction on this space of images.

It's probably mostly distinguishing these by total gray level, but that's kind of showing us the space of different sort of features of

So it's also, what's interesting to see here is things like the symbolic representation of the neural nets.

And if you're wondering, how does that actually work inside, it's underneath.

It's using MXNet, which we happen to have contributed to a lot.

And there's sort of a bunch of symbolic layers on top

Let me show you how you would train 1 of these neural nets.

So we have a data repository that has all sorts of useful data.

1 piece of data it has is a bunch of neural net training sets.

So this is the standard MNIST training set of handwritten digits.

And you notice that these things here, that's just an image, which I could copy out.

And I could do, let's say I could do color negate on that image, because

And now I could say, let's take a neural net, like let's take a simple neural net like Lynette, for example.

Okay, so let's take Lynette, and then let's take the

So this is now a version of Linet, simple standard neural net that didn't get trained.

So for example if I take that symbolic representation of Linet and I could say net initialize, then it will take that and it'll just put random weights into Lynette.

Okay, so if I take those random weights and I feed it a 0 here, I feed it that image of a 0, it will presumably produce something completely random, in this particular case, 2.

So now, now what I would like to do is to take this.

So that was just randomly initializing the weights.

So now what I'd like to do is to take the MNIST training set, and I'd like to actually train Lynette using MNIST training set.

So Let's take this and let's take a random sample of

Let's say I don't know a thousand pieces of Lynette Come on.

Okay, so there's a there's a random sample there is on line 21 and now let me go down here and say, where was it?

So this is the uninitialized version of Lynette and we can say take that and then let's say net train of that with the thing on line 21, which was that 1,000 instances.

So now what it's doing is it's running training on, and that's, you see the loss going down and so on.

It's running training for those 1,000 instances of LaNet, and it will, we can stop it if we want to.

Actually, this is a new display, this is very nice.

This is a new version of Wolfram Language which is coming out next week, which I'm showing you.

But it's quite similar to what exists today.

But because that's 1 of the features of running a software company is that you always run the very latest version of things for better or worse.

And this is also a good way to debug it because it's supposed to come out next week.

If I find some horrifying bug, maybe it will get delayed.

Okay, and so this is now a trained version of LNAT trained with that training data.

1 of the things, so we can talk about all kinds of details of neural nets and so on, but maybe I should zoom out to talk a little bit about bigger picture as I see it.

sort of a question of what is in principle possible to do with computation.

So we have, as we're building all kinds of things, we're making image identifiers, we're figuring out all kinds of things about where the International Space Station is and so on.

Question is, what is in principle possible to compute?

And so, 1 of the places 1 can ask that question is when 1 looks at, for example, models of the natural world.

1 can say, how do we make models of the natural world?

Kind of a traditional approach has been let's use mathematical equations to make models of the natural world.

A question is if we want to kind of generalize that and say well what are all possible ways to make models of things, what can we say about that question?

So I spent many years of my life trying to address that question and basically what I've thought about a lot is that if you want to make a model of a thing, you have to have definite rules by which the thing operates.

What's the most general way to represent possible rules?

Well, in today's world, we think of that as a program.

So the next question is, well what does the space of all possible programs look like?

And most of the time, you know, we're writing programs like Wolfram Language, it's 50 million lines of code, and it's a big complicated program that was built for a fairly specific purpose.

But the question is if we just look at sort of the space of possible programs, more or less at random, what's out there in the space of possible programs?

So I got interested many years ago in cellular automata, which are a really good example of a very simple kind of program.

So let me show you an example of 1 of these.

So these are the rules for a typical cellular automaton.

And this just says you have a row of black and white squares, and this just says you look at a square, say what color is that square, what color are its left and right neighbors, decide what color the square will be on the next step based on that rule.

See all Lex Fridman transcripts on Youtube

Stephen Wolfram: Computational Universe | MIT 6.S099: Artificial General Intelligence (AGI)