YouSub
Untitled

en English

Untitled English subtitles

0 downloads · 890 lines · added Nov 18, 2015

Report a problem
What's wrong?
Advertisement

English transcript

PROFESSOR PATRICK WINSTON: You know, some
of you who for instance--
I don't know, Sonya, Krishna, Shoshana--
some of you I can count on being here every time.
Some of you show up once in a while.
The ones of you who show up once in a while happen to be
very lucky if you picked today, because what we're
going to do today is I'm going to tell you stuff that might
make a big difference in your whole life.
Because I'm going to tell you how you can
make yourself smarter.
No kidding.
And I'm also going to tell you how you can package your ideas
so you'll be the one that's picked instead
of some other slug.
So that's what we're going to do today.
It's the most important lecture of the semester.
The sleep lecture is only the second most important.
This is the most important.
Now the vehicle that's going to get us there is a
discussion about how it's possible to learn in a way
that is a little reminiscent of what we
talked about last time.
Because last time we learned something very definite from a
small number of examples.
This takes it one step further and shows how it's possible to
learn in a human-like way from a single example in one shot.
So it's extremely different, very different from everything
you've seen before.
Everything that involves learning from thousands of
trials and gazillions of examples and only learning a
little tiny bit, if anything, from each of them.
This is going to learn something
definite from every example.
So here's the classroom example.
What's this?
It's an arch.
I know the architects are complaining that it's not an
arch in architecture land.
It's a post and lintel construction.
But for us today it's going to be an arch.
Now if you were from Mars and didn't know what an arch was,
I might present this to you and you'd get a general idea
of some things that might be factors, but you'd have no
idea what's really important.
So then I would say, that's not an arch.
And you would learn something very definite from that.
And then I would shove these together and put this back on,
and I would say, that's not an arch either.
And you'd learn something very definite from that.
And then I could paint the top one blue, and you'd learn
something very different from that.
And how can that happen is the question?
How can that happen in detail, and what might it mean for
human learning and how you can make yourself smarter?
And that's where we're going to go.
All right?
So how can we make a program that's a smart as a martian
about learning things like that?
Well, if you were writing that program, surely the first
thing you would do is you'd try to get off the picture as
quickly as possible and into symbol land where things are
clearer about what the important parts are.
So you'd be presented with an initial example that might
look like this.
We'll call that an example.
And it's more than just an example.
It's the initial model.
That's the starting point.
And now we're going to couple that with something that's not
actually an arch but looks a whole lot like one, at least
on the descriptive level to which we're about to go.
So here's something that's not an arch, but its description
doesn't differ from that of an arch very much.
In fact, if we were to draw this out in a kind of network,
we would have a description that looks like this, and
these relations would be support relations.
And this would be drawn out like so.
And the only difference would be--
the only difference would be that those support relations
that we had in the initial model--
the example--
have disappeared down out here in this configuration.
But since it's not very different from the model,
we're going to call this a near miss.
And now, you see, we've abstracted away from all the
details that don't matter to us.
Last time we talked about a good representation having
certain qualities--
qualities like making the right things explicit.
Well, this makes the structure explicit, and it suppresses
information about blemishes on the surface.
We don't care much about how tall the objects are.
We don't think it matters what they're made of.
So this is a representation that satisfies the first of
the criteria from last time.
It makes the right things explicit.
And by making the right things explicit, it's exposing some
constraint here with respect to what it
takes to be an arch.
And we see that if those support relations are missing,
it's not an arch.
So we ought to be able to learn something from that.
What we're going to do is we're going to put these two
things together.
We're going to describe the difference between the two.
And we're going to reach the conclusion that since there's
only one difference--
one kind of difference with two manifestations to
disappearing support relations, we're going to
conclude that those support relations are important.
And we're going to turn them red
because they're so important.
And we're going to change the name from "support" to "must
support."
So this is our new model.
This is an evolving model that now is decorated with
information about what's important.
So if you're going to match something against this model,
it must be the case that those support relations are there.
If it's not there-- if they're not there, it's not an arch.
All right?
So we've learned something definite
from a single example.
This is not 10,000 trials.
This is a teacher presenting something to the student and
the student learning something immediately in one step about
what's important in an arch.
So let's do it again.
That was so much fun.
Let's do this one.
Same as before except that now when we describe this thing,
there are some additional relations--
these relations, and those are touch relations.
So now when we compare that--
is that an arch?
No.
It's a near miss.
When we compare that near miss with our evolving model, we
see immediately that once again there's exactly one
difference, two
manifestations, the touch relations.
So we can immediately conclude that these touch relations are
interfering with our belief that this could be an arch.
So what do we do with that?
We put those together again and we build
ourselves a new model.
It's much like the old model.
It still has the imperatives up here.
We have to have the support relations.
But now down here-- and we draw not signs through there--
these are must not touch relations.
So now you can't match against that model if those two side
supports are touching each other.
So in just two steps, we've learned two important things
about what has to be in place in order for this thing to be
construed to be an arch.
So our martian is making great progress.
But our martian isn't through, because there's some more
things we might want it to know about
the nature of arches.
For example, we might present it with this one.
Well, that looks just like our initial example.
It's an example just like our initial example.
But this time the top has been painted red.
And I'm still saying that that's an arch.
So once again, there's only one difference and that
difference is that in the description of this object, we
have the additional information that the color of
the top is red.
And we've been carrying along without saying so, that the
color of the top in the evolving model is white.
So now we know that the top doesn't have to be white.
It can be either red or white.
So we'll put those two together and
we'll get a new model.
And that new model this time once again
will have three parts.
It will have the relations, an imperative form that we've
been carrying along now, the must support and the must not
touch, but now we're going to turn that color relation
itself into an imperative.
And we're going to say that the top has to be
either red or white.
So now, once again, in one step we've learned something
definite about archness.
Two more steps.
Suppose now we present it with this example.
It's an example.
And this time there's going to be a little paint
added here as well.
This time we're going to have the top painted blue like so.
So the description will be like so.
And now we have to somehow put that together with our
evolving model to make a new model.
And there's some choices here.
And our choice depends somewhat on the nature of the
world that we're working in.
So suppose we're working in flag world.
There are only three colors--
red, white, and blue.
Now we've seen them all.
If we've seen them all, then what we're going to do is
we're going to say that the evolving model now is adjusted
yet again like so.
Oh-- but those are imperatives still.
Let me carry that along.
At this time, this guy--
the color relation--
goes out here to anything at all.
So we could have just not drawn it at all, but then we
would have lost track of the fact that we've actually
learned that anything can be there.
So we're going to retain the relation but have it point to
the "anything goes" marker.
Well, we're making great progress and I said there's
just one more thing to go.
So let me compress that into this area here.
What I'm going to add this time is I'm going to say that
the example is like everything you've seen before except that
the top is now one of those kinds of child's bricks.
So you have a choice actually about whether this
is an arch or not.
But if I say, yeah, it's still an arch, then we'd add a
little something to its description.
So this description would look like this.
Same things that we've seen before in terms of support,
but now we'd have a relation that says that
this top is a wedge.
And over here--
something we've been carrying along but not writing down--
this top is a block.
A brick, I guess in the language of the day.
So if we say that it can be either a wedge or a brick on
top, what do we do with that?
Once again, it depends on the nature of representation, but
if we say that we have a representation, that has a
hierarchy of parts.
So bricks and wedges are both children's blocks and
children's box or toys.
Then we can think of drawing in a little bit of that
hierarchy right here and saying well, let's see.
Immediately above that we've got the brick or wedge.
And a little bit above that we've got block.
And a little bit above that we've got toy.
And a little bit above that we eventually get to
any physical object.
So what does it do in response to that kind of situation?
You have the choice.
But what the program I'm speaking of actually did was
to make a conservative generalization up here just to
say that it's one of those guys.
So once again it's learned something definite.
Let me see.
Let me count the steps.
One, two, three, four, five.
And I just learned four things.
So the generalization of a color, it took two steps to
get all the way up to "don't care."
So note how it contrasts with anything you've seen in a
neural net.
Or anything you will see downstream in some of the
other learning techniques that we'll be talking about that
involve using thousands of samples to learn what it is--
to learn whatever it is that is intended to be learned.
Let me show you another example of how these
heuristics can be put to work.
So there are two sets of drawings.
We have the upper set and the lower set.
And your task, you smart humans working in vast
parallelism, your task is to give me a description of the
top trains that distinguishes and separates them from the
trains on the bottom.
You got it?
Nobody's got it?
Well, let me try one on you.
The top trains all have a short car with a closed top.
So how is it possible that a computer could have
figured that out?
It turns out that it figured it out with much the same
apparatus that I've shown you here in connection with the
arches, just deployed in a somewhat different manner.
In this particular case, the examples are presented one at
a time by a teacher who's eager for
the student to learn.
In this case, the examples are presented all at once and the
machine is expected to figure out a description that
separates the two groups.
And here's how it works.
What you do is you start with one of them.
But you have a lot of them.
You have some examples--
we'll call the examples on top the "plus examples" and the
examples on the bottom the "negative examples." So the
first thing that you do is you pick one of the positive
examples to work with.
Anybody got any good guesses about what we're
going to call that?
Yeah, you do.
We're going to call that the seed.
It's just highly reminiscent of what we did last time when
we were doing [? phonology ?]
but now at a much different level.
We're going to pick one of those guys to be the seed, and
then we're going to take these heuristics and we're going to
search for one that loosens this description so that it
covers more of the positives.
You see, if you have a seed that is exactly a description
of a particular thing and you insist that everything be just
like that, then nothing will match except itself.
But you can use these heuristics to expand the
coverage of the description, to loosen it so that it covers
more of the positives.
So in your first step you might cover, for example, that
group of objects.
Too bad for your side, you've also in that particular case
included a negative example in your description, but perhaps
in this next step beyond that you'll get to the point where
you've eliminated all of those negative examples and zeroed
in on all the positive examples.
So how might a program be constructed that would do that
sort of thing?
Well, think about the choices.
The first choice that you have it is to pick a positive
example to be the seed.
And once you've picked a particular example to be the
seed, then you can apply heuristics, all of them that
you have, to make a new description that may cover the
data better.
It may have more of the positives and fewer of the
negatives than in your previous step.
But this, if you have a lot of heuristics, and these are a
lot of heuristics because there's a lot of description
in that set of trains, there are lots of possible things
that you could do with those heuristics because you could
apply them anywhere.
So this tree is extremely large.
So what do you do to keep it under control?
Well, now you have answers to questions like that by
knee-jerk, right?
The branching factor is too big.
You want to keep a few solutions going.
You have some way of measuring how well you're doing so you
can use a beam search.
This piece here was originally worked out by a friend of
mine, now, alas, deceased, [? Rashad ?]
[? Malkowski ?]
when he was at the University of Illinois.
And of course, he wasn't interested in toy trains, he
was just interested in soybean diseases.
And so this exact program was used to build descriptions of
soybean diseases.
It turned out to be better than the
plant pathology books.
We now have two ways of deploying the same heuristics.
But my vocabulary is in need of enrichment, because I'm
talking about "those" heuristics.
And one of the nice things that [? Malkowski ?]
did for me a long time ago is give each of them a name.
So here are the names that were developed by
[? Malkowski. ?]
What's happening here?
You're going from an original model to an understanding--
some things are essential.
So he called this the "require link" heuristic.
And here in the next step, we're forbidding some things
from being there.
So [? Malkowski ?]
called that heuristic the "forbid link" heuristic.
And in the next step, we're saying it can be
either red or white.
So we have a set of colors and we're extending it.
And over here in this heuristic, going from red or
white to anything goes, that's essentially forgetting about
color altogether, so we're going to call that "drop link"
even though for reasons of keeping track, we don't
actually get rid of it.
We just have it pointing to the "anything" marker.
And finally, in this last step, what we're doing with
this tree of categories is we're climbing up it one step.
So he called that the "climb tree" heuristic.
So now we have a vocabulary of things we can do in the
learning process, and having that vocabulary gives us power
over it, right?
Because those are names.
We can now say, well, what you need here is
the "drop link" heuristic.
And what you need over there is the "extend set" heuristic.
So now I want to back up yet another time and
say, well, let's see.
When we were working with that phonology stuff, all I did was
generalize.
Are we just generalizing here?
No.
We're both generalizing and specializing.
So when I say that the links over here that are developed
in our first step are essential, this is a
specialization step.
And when I say they can't be--
they cannot be touch relations, that's a
specialization step.
Because we're able to match fewer and fewer things when we
say you can't have touch relations.
But over here, when I go here and say, well, it doesn't have
to be white.
It can also be red.
That's a generalization.
Now we can match more things.
And when I drop the link altogether, that's a
generalization.
And when I climb the tree, that's a generalization.
And that's why when I do this notional picture of what
happens when [? Malkowski ?]
program does a tree search to find a solution to the train
problem, they're both specialization steps which
draw in the number of things that can be matched, and
generalization steps that make it broader.
So, let's see.
We've also got the notion of near miss.
And we've got the notion of example--
some of these things are examples,
some are near misses.
We've got generalization specialization.
Does one go with one or the other, or are they all mixed
up in their relationship to each other?
Can you generalize and specialize with near misses?
What do you think?
You think--
you don't think so, [INAUDIBLE]?
What do you think?
STUDENT: [INAUDIBLE]
specialization.
PROFESSOR PATRICK WINSTON: [INAUDIBLE] lead to
specialization.
Let's see if that's right.
So we've got specialization here, and that's a near miss.
We've got specialization here, and that's a near miss.
We've got generalization here, and that's an example.
And we've got generalization here, and that's an example.
So [INAUDIBLE] has got that one nailed.
The examples always generalize, and the near
misses always specialize.
So we've got apparatuses in place that allow us to both
expand what we could match and shrink what we could match.
So what has this got to do anything?
Well, which one of these methods is better, by the way?
This one--
this one requires a teacher to organize everything up.
This one can handle it in batch mode.
This one is the sort of thing you would need to do with a
human because we don't have much memory.
That one is the sort of thing that a computer's good at
because it has lots of memory.
So which one's better?
Well, it depends on what you're trying to do.
If you're trying to build a machine that analyzes the
stock market, you might want to go that way.
Or soybean diseases, or any one of a variety
of practical problems.
If you're trying to model people, then maybe this is a
way that deserves additional merit.
How do you get all that sorted out?
Well, one way to get it all sorted out is to talk in terms
of what are sometimes called "felicity conditions." So when
I talk about felicity conditions, I'm talking about
a teacher and a student and covenants that
hold between them.
So here's the teacher.
That's me.
And here's the student.
That's you.
And the objective of interaction is to transform an
initial state of knowledge into a new state of knowledge
so that the student is smarter and able to make use of that
new knowledge to do things that couldn't be done before
by the student.
So the student over here has a learner.
And he has something that uses what is learned.
And the teacher over here has a style.
So if any learning is to take place, one side has to know
something about the other side.
For example, it's helpful if the teacher understands the
initial state of the student.
And here's one way of thinking about that.
You can think of what you know as forming a kind of network.
So initially, you don't know anyth
…

Need subtitles from another video?