
Korean: 
이 컨텐츠는 Creative Commons
라이센스를 따릅니다.
이 컨텐츠는 Creative Commons
라이센스를 따릅니다.
여러분의 지원은 
MIT OpenCourseWare가
계속해서 고수준의 교육자원을
무료로 제공하는데 도움이 됩니다
기부 또는 MIT 코스의 추가 자료를
원하시는 분은
기부 또는 MIT 코스의 추가 자료를
원하시는 분은
ocw.mit.edu로 접속하세요
(배경 음악)
오늘 우리가 할 것은
아주 큰 산을
오르는 것입니다
두 매개 변수를 가진
신경망에서 시작해서
6천만 개의 매개 변수를
가진 신경망을 다룰 겁니다
큰 도약이죠

English: 
The following content is
provided under a Creative
Commons license.
Your support will help
MIT OpenCourseWare
continue to offer high-quality
educational resources for free.
To make a donation or to
view additional materials
from hundreds of MIT courses,
visit MIT OpenCourseWare
at ocw.mit.edu.
[MUSIC PLAYING]
PATRICK H. WINSTON: Well,
what we're going to do today
is climb a pretty big
mountain because we're
going to go from a
neural net with two
parameters to discussing
the kind of neural nets
in which people end up dealing
with 60 million parameters.
So it's going to be
a pretty big jump.

Korean: 
그 과정에서
지난 수업 내용 중에
강조하고싶은 것이 있습니다
지난번엔 여러분이
작은 신경망을 계산할 때
사용하는 수식에 대한
직관력을 키우려 했습니다
가중치를 어떤 식으로
두느냐를 말이죠
가장 강조하고 싶은 건
이런 식의 신경망을 가질 때
모든 게 각각의 열로
나뉘어져 있다는것 입니다
이 결과물에 대한 성능이
여기에서 가중치 변동에
관여하지 않습니다
유한개의 출력값을
거치지 않고서야 말이죠
y1들이요
여기에 y2나 y3는 없어요

English: 
Along the way are
a couple things
I wanted to underscore from
our previous discussion.
Last time, I tried to
develop some intuition
for the kinds of formulas
that you use to actually do
the calculations in a
small neural net about how
the weights are going to change.
And the main thing
I tried to emphasize
is that when you have a
neural net like this one,
everything is sort of
divided in each column.
You can't have the performance
based on this output
affect some weight
change back here
without going through this
finite number of output
variables, the y1s.
And by the way, there's no y2
and y4-- there's no y2 and y3.

English: 
Dealing with this is really
a notational nightmare,
and I spent a lot
of time yesterday
trying to clean it
up a little bit.
But basically, what
I'm trying to say
has nothing to do with
the notation I have used
but rather with the
fact that there's
a limited number of ways in
which that can influence this,
even though the number of
paths through this network
can be growing exponential.
So those equations
underneath are
equations that derive
from trying to figure out
how the output performance
depends on some
of these weights back here.
And what I've calculated
is I've calculated
the dependence of
the performance on w1
going that way, and
I've also calculated
the dependence of performance
on w1 going that way.
So that's one of the
equations I've got down there.
And another one
deals with w3, and it

Korean: 
표기법에 진절머리가 나네요
어제 꽤 많은 시간을
투자했어요
이걸 깔끔하게
정리하려고 말이죠
여기서 하고 싶은 말은
표기법과 관련된 게 아니라
저게 이거에 영향을 끼칠
방법이 한정됐다는 거예요
이 네트워크를 따라
만들 수 있는 경로의 수는
기하급수적으로
늘어나지만 말이죠
그래서 아래의 식들은
어떻게 출력값의 성능이
이것들의 가중치에
영향을 받는지 찾기 위해
유도된 것입니다
제가 계산한 것은
이 경로의 w1 성능의 의존도와
그리고 이 경로의 w1
성능의 의존도를 계산했어요
마지막 결과물 중의
일부입니다
다른 건 w3와
관련된 식인데

English: 
involves going both
this way and this way.
And all I've done in both
cases, in all four cases,
is just take the partial
derivative of performance
with respect to those weights
and use the chain rule
to expand it.
And when I do that,
this is the stuff I get.
And that's just a whole
bunch of partial derivatives.
But if you look at it and let
it sing a little bit to you,
what you see is that
there's a lot of redundancy
in the computation.
So for example, this
guy here, partial
of performance
with respect to w1,
depends on both
paths, of course.
But look at the first elements
here, these guys right here.
And look at the first
elements in the expression
for calculating the partial
derivative of performance

Korean: 
이 방향과 이 방향
모두를 포함합니다
4개의 모든 경우에 대해
계산을 했고
가중치에 대한 성능을
편미분을 하고
연쇄 법칙을 사용해서
확장했습니다
이 방법에 따라
이런 결과가 나옵니다
다 편도 함수죠
하지만 유심히 들여다보면
계산식에 반복이
많다는 걸 알 수 있습니다
예를 들어서 이건
w1에 대한 성능의
편미분이죠
경로 두 개 다에
관해서 말이죠
여기 첫 부분만
한번 볼까요
그리고 여기 첫 부분을
또 한번 봅시다
w3에 대해
성능을 편미분 한 것이요

English: 
with respect to w3, these guys.
They're the same.
And not only that, if you
look inside these expressions
and look at this
particular piece here,
you see that that is
an expression that
was needed in order
to calculate one
of the downstream weights,
the changes in one
of the downstream weights.
But it happens to be the same
thing as you see over here.
And likewise, this piece is the
same thing you see over here.
So each time you move
further and further back
from the outputs
toward the inputs,
you're reusing a
lot of computation
that you've already done.
So I'm trying to find a
way to sloganize this,

Korean: 
얘들 말이에요
둘이 같아요
그뿐만 아니라
수식 내부를 보면
이 부분을 보면
후속 가중치 중 하나를
계산할 때 필요한 식이었어요
여길 보면
똑같은 게 반복된 거에요
비슷하게 이 부분도
여기서 볼 수 있어요
더 뒤로 움직일수록
출력값에서 입력값으로
이미 했던 계산을
다시 사용하게 됩니다
이걸 슬로건화하는
방법을 찾고 있어요
그래서 내린 결론은

Korean: 
지나간 일은 할 수 없고
아 그렇게 표현하면
안되겠네요
이미 계산된 건 계산된 거고
다시 할 필요는 없다
이해가 되나요?
그게 여기서
벌어지고 있는 일이고
그리고 이게 왜
신경망의 깊이에 따라
지수가 아닌
선형인 이유입니다
이 신경망과의 연결에 대해
짚고 넘어가고 싶은 게 하나 더 있어요
하나의 뉴런을 봤을 때
일어나는 일과 연관되어 있는데
우리가 가지고 있는 것은
수많은 입력값에
가중치를 곱한 것이죠
이 모든 건 합계 상자
안에서 더해집니다
선형이 아닌 함수에
들어가기 전에 말이죠

English: 
and what I've come up with is
what's done is done and cannot
be-- no, no.
That's not quite right, is it?
It's what's computed is computed
and need not be recomputed.
OK?
So that's what's going on here.
And that's why this is
a calculation that's
linear in the depths of the
neural net, not exponential.
There's another thing I wanted
to point out in connection
with these neural nets.
And that has to do
with what happens
when we look at a single neuron
and note that what we've got
is we've got a bunch of
weights that you multiply times
a bunch of inputs like so.
And then those are all
summed up in a summing box
before they enter some kind
of non-linearity, in our case

Korean: 
여기서는
시그모이드 함수입니다
만약 제가 여러분에게
식을 작성하라고 한다면
우리가 가진 값들로 말이죠
그럼 w와 x들의 곱을
더한 값이 되겠네요
그게 뭐죠?
내적이네요
제가 얼마 전 수업 시간에
말했던 거 기억나세요?
몇몇 사람들이 내적이
가장 근본적인 계산법이라
믿는다고 말이죠
우리 머리 속에서
일어나는 것 중에서요
이게 그 이유입니다
만약 신경망이 이와
비슷한 걸 한다면
어떠한 가중치와 입력값을
내적할 겁니다
좀 재미있는 값이 나오는데
우리가 사용했던 모델에서
입력값은 모두
0 또는 1이었거든요
그래도 괜찮습니다
제가 권한을 가지고 있거든요

English: 
a sigmoid function.
But if I ask you to write down
the expression for the value
we've got there, what is it?
Well, it's just the sum
of the w's times the x's.
What's that?
That's the dot product.
Remember a few lectures
ago I said that some of us
believe that the dot product is
a fundamental calculation that
takes place in our heads?
So this is why we think so.
If neural nets are doing
anything like this,
then there's a dot product
between some weights
and some input values.
Now, it's a funny
kind of dot product
because in the models
that we've been using,
these input variables are
all or none, or 0 or 1.
But that's OK.
I have it on good
authority that there
are neurons in our head
for which the values that

Korean: 
머리 속에 있는 뉴런이
생성하는 값이
0 또는 1이 아니라
비례의 원칙을
갖는 다는 거죠
내적 같은 종류의
계산 과정을 얻을 겁니다
이것들이 제가 강조하고
싶었던 부분이고
오늘의 핵심 내용에
들어가기 앞서서 말이죠
심층 신경망에 대해
알아볼 겁니다
심층 신경망이 무엇을
하는지 알아봅시다
저번 시간에 이어서
심층 신경망은 이런 걸 합니다
몇몇 결과물을 보면
흥미롭습니다
2012년에 성능이
얼마나 좋았을까요?
상위 5개 안에 정답을
맞출 확률은 15%였어요
첫 번째 답안이 맞았을 경우가
37% 입니다

English: 
are produced are not
exactly all or none
but rather have a kind of
proportionality to them.
So you get a real dot product
type of operation out of that.
So that's by way of
a couple of asides
that I wanted to
underscore before we
get into the center
of today's discussion,
which will be to talk about
the so-called deep nets.
Now, let's see,
what's a deep net do?
Well, from last time, you
know that a deep net does
that sort of thing, and
it's interesting to look
at some of the offerings here.
By the way, how good was
this performance in 2012?
Well, it turned out
that the fraction
of the time that the
system had the right answer
in its top five
choices was about 15%.
And the fraction of the time
that it got exactly the right
answer as its top pick
was about 37%-- error,

English: 
15% error if you count it as
an error if it's-- what am I
saying?
You got it right if you
got it in the top five.
An error rate on that
calculation, about 15%.
If you say you only get it right
if it was your top choice, then
the error rate was about 37%.
So pretty good, especially
since some of these things
are highly ambiguous even to us.
And what kind of
a system did that?
Well, it wasn't one
that looked exactly
like that, although that
is the essence of it.
The system actually
looked like that.
There's quite a lot
of stuff in there.
And what I'm going to talk about
is not exactly this system,
but I'm going to talk about the
stuff of which such systems are
made because there's
nothing particularly
special about this.
It just happens to be
a particular assembly
of components that tend to
reappear when anyone does
this sort of neural net stuff.
So let me explain that this way.

Korean: 
15% 에러가...
제가 뭐라는 거죠?
상위 5개에 들면
맞춘 거예요
그 계산에 대한
에러율은 15%입니다
만약 최상의 선택만을
정답으로 여긴다면
에러율은 37%입니다
꽤나 만족스러워요
몇몇은 우리에게도
애매하게 보이거든요
그럼 어떤 시스템이
이런 결과를 가져왔을까요?
칠판에 쓴 것과
완전히 같은 건 아닙니다
물론 저게 기본적인 개념을
포함하고 있긴 하지만요
사실은 이렇게 생겼습니다
많은 게 있는데
저는 이 시스템에 대해
말하려고 하는 게 아니라
그러한 시스템이 만들어지는 것들에
대해서 말하려고 합니다
별로 특별한 게 없기 때문이죠
그냥 특정한 구성의 조합이에요
누구든 신경망으로 무엇을 할 때
다시 나타나곤 하죠
이렇게 한번 설명해보죠

Korean: 
먼저 이 개념에 대해서
설명해야겠네요
용어를 좋아하지 않지만
합성곱(convolution)이라고 불립니다
제가 이 용어를
좋아하지 않는 이유는
우리 학교에서 두 번째로
좋은 강의 - 신호와 시스템에서
임펄스 응답과 중첩 적분에
대해서 배우죠
힌트가 되긴 하지만
완전히 같은 건 아닙니다
신호가 처리될 때는
메모리를 포함하지 않거든요
어쨌거나 합성곱 신경망이라
부릅니다
자 여기
어떤 이미지가 있다고 해봅시다
높은 연산력과
고성능의 GPU가 있어도
픽셀 4백만 개의
이미지를 말하는 게 아니에요
256x256 픽셀 정도의
이미지를 가지고 있어요
1000x1000이나
4000x4000의
이미지를
말하는 게 아닙니다

English: 
First thing I need to talk
about is the concept of-- well,
I don't like the term.
It's called convolution.
I don't like the term because
in the second-best course
at the Institute,
Signals and Systems,
you learn about impulse
responses and convolution
integrals and stuff like that.
And this hints at that,
but it's not the same thing
because there's no memory
involved in what's going on
as these signals are processed.
But they call it convolutional
neural nets anyway.
So here you are.
You got some kind of image.
And even with lots of computing
power and GPUs and all
that sort of stuff, we're
not talking about images
with 4 million pixels.
We're talking about images
that might be 256 on a side.
As I say, we're not
talking about images
that are 1,000 by 1,000 or 4,000
by 4,000 or anything like that.

English: 
They tend to be
kind of compressed
into a 256-by-256 image.
And now what we do
is we run over this
with a neuron that
is looking only
at a 10-by-10 square like so,
and that produces an output.
And next, we went
over that again having
shifted this neuron
a little bit like so.
And then the next thing we do
is we shift it again, so we
get that output right there.
So each of those deployments
of a neuron produces an output,
and that output is associated
with a particular place
in the image.
This is the process that
is called convolution
as a term of art.

Korean: 
256x256으로
압축되어 있습니다
그다음으로 우리는
이걸 실행하는데
10x10 만 보는
뉴런으로 말입니다
이것처럼 말이에요
이게 출력값을 생성합니다
그다음에 뉴런을 약간
옮겨서 다시 실행합니다
그다음에 또 옆으로
옮겨줍니다
그럼 이런 출력값이
나올 겁니다
뉴런의 배치가
각각 다른 출력값을 만들고
출력값은 이미지의 특정한
위치와 연관되어 있습니다
이게 바로 합성곱이라고
불리는 과정입니다

English: 
Now, this guy, or this
convolution operation,
results in a bunch
of points over here.
And the next thing that
we do with those points
is we look in
local neighborhoods
and see what the
maximum value is.
And then we take
that maximum value
and construct yet another
mapping of the image
over here using
that maximum value.
Then we slide that over like so,
and we produce another value.
And then we slide
that over one more
time with a different
color, and now we've
got yet another value.
So this process
is called pooling.
And because we're
taking the maximum,

Korean: 
이 합성곱 작업은
매우 많은 점을 생성합니다
이 점을 가지고
다음으로 할 건
옆 값들을 비교해서
최댓값이 무엇인지
알아내는 것입니다
최댓값을 가져와서
이미지를 다시 매핑하는 거죠
최댓값들을 이용해서 말입니다
하나 옆으로 밀어서
새로운 값을 만들어냅니다
하나 옆으로 또 밀어내서
다른 색으로 해봅시다
그럼 또 다른 값을 얻습니다
이러한 과정을
풀링(pooling)이라고 합니다
최댓값을 선택하기 때문에

Korean: 
이것을 특별히 최대 풀링
(max pooling)이라고 합니다
다음 과정이 무엇인지
한번 봅시다
특정 뉴런을 가져와서
다른 이미지에 입히는 겁니다
이걸 커널(kernel)이라고 합니다
또 신호와 시스템에서
가져온 용어네요
그다음으로 우리가 할 건
많은 커널을 사용할 수 있습니다
하나의 커널로 만들 수 있는 게
여러 번 반복됩니다
이런 식으로 말이죠
보통 100번 정도 반복합니다
이제 우리에겐 256x256의
이미지가 있고
10x10 커널을 적용했습니다
각 위치에서의 최댓값을 뽑아서
100번을 반복합니다
그 값을 가지고
어떠한 신경망에 결과를
적용할 수 있습니다

English: 
this particular kind of
pooling is called max pooling.
So now let's see what's next.
This is taking a
particular neuron
and running it across the image.
We call that a kernel, again
sucking some terminology out
of Signals and Systems.
But now what we're
going to do is
we're going to say we could
use a whole bunch of kernels.
So the thing that I
produce with one kernel
can now be repeated
many times like so.
In fact, a typical
number is 100 times.
So now what we've got is
we've got a 256-by-256 image.
We've gone over it
with a 10-by-10 kernel.
We have taken the
maximum values that
are in the vicinity
of each other,
and then we repeated
that 100 times.
So now we can take that, and
we can feed all those results
into some kind of neural net.
And then we can, through
perhaps a fully-connected job

Korean: 
마지막 레이어에서
완전 연결(fully connected)을 하고나면
최종 출력에서
mite라는 것을 볼 수 있습니다
이게 대략적인
과정입니다
지금까지 어떤 걸
얘기해왔죠?
풀링, 합성곱에 대해
알아봤고
이제 다른 좋은 것들에
대해 알아봅시다
그전에 이게 우리가
할 수 있는 일입니다
이전에 했던 방법과
비교할 수 있습니다
방대한 양의 계산이
불가능하던 시절에는
조금 알아보기 쉬운
신경망 활동이었습니다

English: 
on the final layers of this, and
then in the ultimate output we
get some sort of
indication of how likely it
is that the thing that's
being seen is, say, a mite.
So that's roughly how
these things work.
So what have we
talked about so far?
We've talked about pooling, and
we've talked about convolution.
And now we can talk about
some of the good stuff.
But before I get into that,
this is what we can do now,
and you can compare this with
what was done in the old days.
It was done in the old
days before massive amounts
of computing became available
is a kind of neural net activity
that's a little easier to see.

Korean: 
예전에는 계산 능력이
떨어져서
작은 그리드의
화소만 다룰 수 있었죠
픽셀이라고도 합니다
이 값들은 어떠한 뉴런에
입력값이 될 수 있겠죠
이미지에 이 픽셀에 해당하는
픽셀 열이 있을 수 있겠네요
열이 몇 개 더 있고
마지막으로
이 뉴런이 숫자 1을
찾고 있다고 합니다
이미지에 숫자 1
같은 게 있다는 거죠
여기 위에 있는 것들은
방대한 양을
계산할 능력이 될 때
가능한 방법이죠
옛날과 비교해서 말입니다
차이점이 무엇일까요

English: 
You might, in the old days,
only have enough computing power
to deal with a small
grid of picture elements,
or so-called pixels.
And then each of these might be
a value that is fed as an input
into some kind of neuron.
And so you might have a column
of neurons that are looking
at these pixels in your image.
And then there might be
a small number of columns
that follow from that.
And finally, something
that says this neuron
is looking for things that are
a number 1, that is to say,
something that looks like
a number 1 in the image.
So this stuff up
here is what you
can do when you have a
massive amount of computation
relative to the
kind of thing you
used to see in the old days.
So what's different?
Well, what's
different is instead

English: 
of a few hundred parameters,
we've got a lot more.
Instead of 10 digits,
we have 1,000 classes.
Instead of a few
hundred samples,
we have maybe 1,000
examples of each class.
So that makes a million samples.
And we got 60 million
parameters to play with.
And the surprising thing
is that the net result
is we've got a function
approximator that
astonishes everybody.
And no one quite
knows why it works,
except that when you throw an
immense amount of computation
into this kind of
arrangement, it's
possible to get a performance
that no one expected would
be possible.
So that's sort of
the bottom line.
But now there are a couple of
ideas beyond that that I think
are especially interesting,
and I want to talk about those.
First idea that's
especially interesting

Korean: 
수백 개가 아니라
훨씬 많은 매개 변수가
있다는 점이죠
10자리 수가 아니라
1000개의 클래스가 있어요
수백 개의 샘플이 아니라
각 클래스 마다
1000개의 예시가 있다는 거죠
백 만개의 샘플이
나온다는 겁니다
6천 만개의 매개 변수를
가지게 됩니다
여기서 놀라운 점은
최종 결과가
모두를 놀라게 하는 함수 근사자 (function
approximator)를 가진다는 겁니다
아무도 왜 이렇게
작동하는지 모릅니다
이런 배열에다가
많은 양의 계산을 시키고
불가능이라고 생각했던
성능을 낸다는 점만 빼고 말이죠
그게 거의 핵심입니다
그 밖에 제가 흥미롭다고
생각하는 개념이 있는데
거기에 대해
조금 더 말해볼게요
첫 번째 개념은

Korean: 
자동 코딩이 가능하다는
점입니다
이게 자동 코딩이
가능한 이유입니다
칠판에 공간이 부족해서
여기다가 바로 해야겠네요
몇 개의 입력값이 있습니다
뉴런 층으로 들어가는데
입력층이라고 합니다
다음으로 훨씬 작은
은닉층이 있습니다
예를 들어
여기에 뉴런 10개가 있으면
여기에는 몇 개밖에 없겠죠
이건 다시 출력층으로
확장됩니다
이제 출력층을
z1부터 zn까지

English: 
is the idea of
autocoding, and here's
how the idea of
autocoding works.
I'm going to run
out of board space,
so I think I'll
do it right here.
You have some input values.
They go into a layer of
neurons, the input layer.
Then there is a so-called hidden
layer that's much smaller.
So maybe in the example,
there will be 10 neurons here
and just a couple here.
And then these expand to
an output layer like so.
Now we can take the output
layer, z1 through zn,
and compare it with the
desired values, d1 through dn.

English: 
You following me so far?
Now, the trick is to say, well,
what are the desired values?
Let's let the desired
values be the input values.
So what we're going
to do is we're
going to train this net
up so that the output's
the same as the input.
What's the good of that?
Well, we're going to
force it down through this
[? neck-down ?]
piece of network.
So if this network
is going to succeed
in taking all the possibilities
here and cramming them
into this smaller inner layer,
the so-called hidden layer,
such that it can reproduce
the input [? at ?] the output,
it must be doing some
kind of generalization
of the kinds of things
it sees on its input.
And that's a very clever idea,
and it's seen in various forms

Korean: 
목표값과 비교하면 됩니다
d1부터 dn까지 말이죠
다들 따라오고 있나요?
여기서 문제는
목표값이 대체 무엇일까요
목표값을 입력값이라고
해봅시다
이제 우리가 할 일은
네트워크를 학습시켜서
출력값이 입력값과
같게 하는 것입니다
그렇게 해서 좋은 점이 뭘까요
더 작은 네트워크로
통과시킬 건데
만약 이 네트워크가 성공하면
여기있는 모든 가능성을 가지고
이 작은 내부층에 넣고
은닉층에 말이죠
입력값을 출력값으로
복사할 수 있다면
아마도 어떠한 
일반화를 하고 있다는 건데
입력값으로
보이는 것을 말이죠
아주 똑똑한 생각이고
많은 형태로 보이고 있어요

English: 
in a large fraction
of the papers that
appear on deep neural nets.
But now I want to
talk about an example
so I can show you
a demonstration.
OK?
So we don't have GPUs, and
we don't have three days
to do this.
So I'm going to make up a
very simple example that's
reminiscent of what goes
on here but involves
hardly any computation.
What I'm going to
imagine is we're
trying to recognize
animals from how tall they
are from the shadows
that they cast.
So we're going to recognize
three animals, a cheetah,
a zebra, and a giraffe, and
they will each cast a shadow
on the blackboard like me.
No vampire involved here.
And what we're
going to do is we're

Korean: 
심층 신경망에 나타나는
큰 종이 조각으로 말이죠
그런데 지금은
예제에 대해 얘기하고 싶네요
데모를 보여주기
위해서 말이죠
어떤가요?
우리는 GPU도 없고
3일 동안 계산할 시간도 없어요
그래서 아주 간단한
예제를 만들어 볼겁니다
여기서 일어나는 것을
떠올리게 하지만
어려운 계산 식은
배제한 걸로 말이에요
제가 상상하고자
하는 것은
동물을 인식하는 건데
그림자가 얼마나
큰지로부터 알아내는 거에요
세 종류의 동물을
구분해볼 겁니다
치타, 얼룩말, 기린이요
각각의 동물은 저처럼 칠판에
그림자를 비출겁니다
뱀파이어는 여기에 포함되지 못하겠군요
이제 우리가 할 건

Korean: 
그림자를 신경망의
입력값으로 사용합니다
이해가 잘 되나요?
그게 어떻게 작용하는지
한번 알아봅시다
여기에 우리의
네트워크가 있습니다
테스트 샘플 하나를
선택하면
이건 치타가 만드는
그림자의 키이고요
각각 레벨에 해당하는
10개의 입력 뉴런이 있습니다
얘네는 3개의 내부층
뉴런을 통과하고
외층 뉴런으로
확장됩니다
외층 값을 목표값과
비교해볼 겁니다
목표값은 입력값과
같습니다
이건 입력값의 열이고
가장 오른쪽에
목표값 열이 있습니다

English: 
going to use the shadow as
an input to a neural net.
All right?
So let's see how
that would work.
So there is our network.
And if I just clicked into
one of these test samples,
that's the height of the shadow
that a cheetah casts on a wall.
And there are 10 input
neurons corresponding
to each level of the shadow.
They're rammed through
three inner layer neurons,
and from that it spreads out and
becomes the outer layer values.
And we're going to
compare those outer layer
values to the desired values,
but the desired values
are the same as
the input values.
So this column is a
column of input values.
On the far right, we have
our column of desired values.

English: 
And we haven't trained
this neural net yet.
All we've got is
random values in there.
So if we run the test samples
through, we get that and that.
Yeah, cheetahs are short,
zebras are medium height,
and giraffes are tall.
But our output is just pretty
much 0.5 for all of them,
for all of those shadow
heights, all right,
[? with ?] no training so far.
So let's run this thing.
We're just using simple
[? backdrop, ?] just like on
our world's simplest neural net.
And it's interesting
to see what happens.
You see all those
values changing?
Now, I need to mention that
when you see a green connection,
that means it's a
positive weight,
and the density of the green
indicates how positive it is.
And the red ones are
negative weights,
and the intensity of the
red indicates how red it is.
So here you can
see that we still
have from our random
inputs a variety

Korean: 
이 신경망은 아직
학습하지 않았습니다
우린 지금 무작위의
값을 가지고 있을 뿐이죠
테스트 샘플을 돌리면
이것과 이것을 얻습니다
치타는 작고
얼룩말은 중간 크기이고
기린은 큽니다
그런데 출력값은
모든 것의 0.5밖에 되지 않아요
모든 그림자 크기에
대해 말입니다
아직 학습하지 않았어요
이걸 한번 돌려볼게요
우리는 지금 아주
간단한 걸 돌리고 있어요
세상에서 가장 간단한
신경망이에요
결과를 보면 
참 흥미롭습니다
값들이 변화하는 게 보이나요?
여기서 짚고 넘어갈 건
저기 초록색 연결은
양의 가중치를 뜻하고
초록색의 농도는
얼마나 양의 값인지를 뜻하고
빨간색은 음의 가중치
빨간 정도는 얼마나
음의 값인지를 알려줍니다
여기서 볼 수 있는 건

Korean: 
다양한 초록, 빨간색의
무작위 입력값이 있다는 거죠
아직 많은 학습을
하지 않아서
아직은 무작위의 
값들로만 보이네요
이걸 돌려보면
1000번의 반복 끝에
출력을 입력값과
같게 만드는 노력 끝에
에러율이 떨어지는 점에
도달하게 됩니다
떨어지는 정도가 너무 커서
테스트 케이스를
다시 보는 게 흥미로워요
여기 치타에 대한
테스트 케이스가 있습니다
이제 출력값이 목표값과
매우 비슷해집니다
모든 출력 뉴런에
대해서 말입니다
다른 걸 봐도
오른쪽 두 열이
서로 대응합니다
마지막 결과를 봐도
오른쪽 두 열이
대응하는 것이 보이네요
한 걸음 물러나서 보면
여기서 무슨 일이
일어나고 있는 거죠?

English: 
of red and green values.
We haven't really
done much training,
so everything correctly
looks pretty much random.
So let's run this thing.
And after only 1,000 iterations
going through these examples
and trying to make the
output the same as the input,
we reached a point where
the error rate has dropped.
In fact, it's
dropped so much it's
interesting to relook
at the test cases.
So here's a test case
where we have a cheetah.
And now the output
value is, in fact,
very close to the desired value
in all the output neurons.
So if we look at
another one, once again,
there's a correspondence
in the right two columns.
And if we look at the
final one, yeah, there's
a correspondence in
the right two columns.
Now, you back up from
this and say, well,
what's going on here?

Korean: 
여러분은 동물을 구분하려고
학습시키는 게 아닙니다
자연에서 보이는 것들을
이해하기 위해서
학습을 시키는 겁니다
여기서 보이는 건
그림자의 키 뿐입니다
이건 여러분이 분류를
원한다는 걸 알지 못해요
여기서 볼 수 있는 건
데이터 종류의 일관성이죠
입력값에 따라 말이죠
맞습니까?
오 멋있네요
라고 할 수 있겠네요
지금 일어나고 있는 건
은닉층이
모든 것들이 좁은
통로로 통과하게 돼 있으니
어떠한 일반화를
하게 될 거라는 거죠
우리가 각각의
뉴런을 클릭하면
특정한 키를 볼 수
있도록 설정되는데
그게 입력값에 
표시되었기 때문이죠
최대 시뮬레이션이
뉴런에 어떻게 보이는지
한번 봅시다
은닉층에서 말이죠
이것을 클릭하면

English: 
It turns out that you're
not training this thing
to classify animals.
You're training it to understand
the nature of the things
that it sees in the
environment because all it sees
is the height of a shadow.
It doesn't know anything
about the classifications
you're going to try
to get out of that.
All it sees is that there's
a kind of consistency
in the kind of data that it
sees on the input values.
Right?
Now, you might say,
OK, oh, that's cool,
because what must
be happening is
that that hidden layer,
because everything is forced
through that narrow
pipe, must be doing
some kind of generalization.
So it ought to be the
case that if we click
on each of those
neurons, we ought
to see it specialize
to a particular height,
because that's the sort of stuff
that's presented on the input.
Well, let's go see
what, in fact, is
the maximum
stimulation to be seen
on the neurons in
that hidden layer.
So when I click on these
guys, what we're going to see

Korean: 
뉴런을 최대한 활성화하는
입력값을 볼 수 있습니다
저는 이게 왜 이렇게
되는지 알지 못합니다
초기화 과정이
무작위이거든요
좋습니다
'작은' 걸
일반화한 것으로 보이군요
'중간'으로 보이지 않는데요
최대 활성화
(maximum stimulation)는
밑의 뉴런의 자극을
포함하지 않습니다
이걸 한번 보세요
큰 것으로 보이지 않는 데요
하나는 작은 것으로 추정되는데
다른 두 개는 완벽하게
랜덤으로 보입니다
아이디어를 철회해야겠네요
은닉층에서 일반화를
한다는 것과
그 안에서 일어나는 게
일반화를 인코딩한다는 걸요
우리가 볼 수 있는 걸
인코딩하는 게 아니라

English: 
is the input values
that maximally
stimulate that neuron.
And by the way, I
have no idea how
this is going to turn out
because the initialization's
all random.
Well, that's good.
That one looks like
it's generalized
the notion of short.
Ugh, that doesn't
look like medium.
And in fact, the
maximum stimulation
doesn't involve any stimulation
from that lower neuron.
Here, look at this one.
That doesn't look like tall.
So we got one that looks
like short and two that
just look completely random.
So in fact, maybe we
better back off the idea
that what's going on
in that hidden layer
is generalization
and say that what
is going on in there
is maybe the encoding
of a generalization.
It doesn't look like
an encoding we can see,

Korean: 
다시 정리해서 말할게요
자극 값이 일반화된 게
보이는 게 아닙니다
대신 우리가 가지고 있는 건
일반화를 인코딩한 거죠
우리가 이걸 인코딩했기 때문에
신경망을 이해하기 매우
어려워진 것입니다
우리는 얘네가 뭘
하는지 이해하지 못합니다
왜 치타라고 인식하는 지도
이해하지 못합니다
왜 어떨 땐 통학버스라고
인식하고
다른 경우엔 아니라고
하는지도 몰라요
뉴런이 어디에 반응하는 건지
이해하지 못하기 때문이죠
사실 아주 정확한 건 아니에요
최근에 그걸 풀기 위한
많은 연구가 있었어요
그래도 아직 많은
의문점이 남아있어요
어쨌든 그게
자동 코딩에 대한 개념입니다
여러 형태로 나오는데
몇몇 사람들은 볼츠만 머신에
대해 얘기하곤 하죠
다 같은 이야기입니다
층별로 하면 됩니다
입력 층을 학습시키면
그 층을 이용해서
다음 층을 학습시키고

English: 
but there is a generalization
that's-- let me start that
over.
We don't see the generalization
in the stimulating values.
What we have instead
is we have some kind
of encoded generalization.
And because we got
this stuff encoded,
it's what makes these neural
nets so extraordinarily
difficult to understand.
We don't understand
what they're doing.
We don't understand why they
can recognize a cheetah.
We don't understand why
it can recognize a school
bus in some cases,
but not in others,
because we don't
really understand
what these neurons
are responding to.
Well, that's not quite true.
There's been a lot
of work recently
on trying to sort that
out, but it's still
a lot of mystery in this world.
In any event, that's
the autocoding idea.
It comes in various guises.
Sometimes people talk about
Boltzmann machines and things
of that sort.
But it's basically all
the same sort of idea.
And so what you can
do is layer by layer.
Once you've trained
the input layer,
then you can use that layer
to train the next layer,

Korean: 
그게 그다음 층을
학습시킬 수 있습니다
그리고 아주 마지막에
이런 말을 할 수 있죠
“자 나는 환경과 환경에서
볼 수 있는 것에 대해
많은 지식을 축적했어”
이제 특정 클래스의 샘플을
사용할 때가 왔습니다
그게 자동 코딩에 대한
이야기입니다
다음으로 얘기할 건
최종 층인데요
최종 층이 어떻게
생겼을지 한번 봅시다
이렇게 생겼을 수도 있겠고
여기에 합이 있고
-1이 여기에 있어요
아니
아니
-1이 여기에 있고
증폭기가 있고
임계값이 있습니다

English: 
and then that can train
the next layer after that.
And it's only at the very, very
end that you say to yourself,
well, now I've accumulated
a lot of knowledge
about the environment and what
can be seen in the environment.
Maybe it's time to
get around to using
some samples of particular
classes and train on classes.
So that's the story
on autocoding.
Now, the next thing to talk
about is that final layer.
So let's see what the final
layer might look like.
Let's see, it might
look like this.
There's a [? summer. ?]
There's a minus 1 up here.
No.
Let's see, there's a
minus 1 up-- [INAUDIBLE].
There's a minus 1 up there.
There's a multiplier here.
And there's a
threshold value there.

English: 
Now, likewise, there's some
other input values here.
Let me call this one x, and it
gets multiplied by some weight.
And then that goes into
the [? summer ?] as well.
And that, in turn, goes into
a sigmoid that looks like so.
And finally, you get an
output, which we'll z.
So it's clear that if you
just write out the value of z
as it depends on those inputs
using the formula that we
worked with last
time, then what you
see is that z is
equal to 1 over 1

Korean: 
비슷하게 여기 
다른 입력값이 있습니다
x라고 할게요
어떤 가중치로 곱해집니다
이것 또한
총합에 더해집니다
이게 또 시그모이드에
들어가게 됩니다
마지막으로 z라는
출력값을 가지게 됩니다
z의 값을 쓰면 되는데
지난 시간에 다뤘던 식에서의
입력값들 때문이죠

Korean: 
z가 1/{1+e^(-2wx+T)}
라는 걸 알 수 있죠
좋습니다
이게 시그모이드 함수입니다
가중치의 값과 임계 값에
따라 결정됩니다
그 값이 어떻게 결과를
바꾸는지 한번 봅시다
여기 일반적인
시그모이드 함수가 있습니다
임계 값에 따라
이동하면 어떻게 될까요?
임계 값을 바꾸면
시그모이드가 내려가는 부분으로
움직이게 됩니다
T 값이 바뀌면
이렇게 이동합니다
w 값을 바꾸면
이것의 기울기가 변하게 되죠

English: 
plus e to the minus w times
x minus T-- plus T, I guess.
Right?
So that's a sigmoid
function that
depends on the
value of that weight
and on the value
of that threshold.
So let's look at how those
values might change things.
So here we have an
ordinary sigmoid.
And what happens if we shift
it with a threshold value?
If we change that
threshold value,
then it's going
to shift the place
where that sigmoid comes down.
So a change in T
could cause this thing
to shift over that way.
And if we change
the value of w, that
could change how
steep this guy is.

English: 
So we might think that the
performance, since it depends
on w and T, should be
adjusted in such a way
as to make the classification
do the right thing.
But what's the right thing?
Well, that depends on the
samples that we've seen.
Suppose, for example, that
this is our sigmoid function.
And we see some examples of a
class, some positive examples
of a class, that
have values that
lie at that point and
that point and that point.
And we have some values that
correspond to situations where
the class is not one of the
things that are associated
with this neuron.

Korean: 
그래서 우리는 이것의 성능이
w와 T 값에 달렸기 때문에
분류를 잘하는 방향으로
조정되어야 합니다
분류를 잘한다는 게
뭘까요?
그건 우리가 본
샘플에 따라 달렸습니다
만약 이게 우리의
시그모이드 함수라고 한다면
양의 클래스
예제 몇 개를 봤다면
이 세 개의 점에 해당하는
값들이 있을 겁니다
이 뉴런과 관련 없는 클래스에
해당하는 값도 있겠고요

Korean: 
그런 경우에는
이것과 가까운 예시를
볼 수 있겠네요
여기서 이 특정한 값을
보게 될 확률은
시그모이드 곡선 위의
값과 관련 있습니다
이걸 그 양의 예시의
확률이라고 생각하면 되요
이것도 그 양의 예시에
대한 확률이고
저것도 그 양의 예시에
대한 확률이 되겠죠
그럼 이 음의 예시에
대한 확률은 무엇일까요
곡선 위 값에
1 마이너스입니다
이것도 곡선 위 값에
마이너스 1을 한 거고요
계산을 통해 우리가
알 수 있는 건
이 데이터를 볼 수 있는
확률을 높이는 방법은
이 특정한 환경에서 말이죠
확률을 최대화하기 위해서
T와 w값을 조정해야 합니다
곡선이 최적의 결과를
낳게 하기 위해서 말이죠
전혀 이해에 
어려울 것이 없습니다

English: 
And in that case, what
we see is examples that
are over in this vicinity here.
So the probability that we
would see this particular guy
in this world is associated with
the value on the sigmoid curve.
So you could think of
this as the probability
of that positive
example, and this
is the probability of
that positive example,
and this is the probability
of that positive example.
What's the probability
of this negative example?
Well, it's 1 minus the
value on that curve.
And this one's 1 minus
the value on that curve.
So we could go through
the calculations.
And what we would determine
is that to maximize
the probability of seeing this
data, this particular stuff
in a set of experiments, to
maximize that probability,
we would have to adjust T and
w so as to get this curve doing
the optimal thing.
And there's nothing
mysterious about it.

English: 
It's just more
partial derivatives
and that sort of thing.
But the bottom line is that the
probability of seeing this data
is dependent on the
shape of this curve,
and the shape of this curve is
dependent on those parameters.
And if we wanted to maximize
the probability that we've
seen this data, then we have
to adjust those parameters
accordingly.
Let's have a look
at a demonstration.
OK.
So there's an ordinary
sigmoid curve.
Here are a couple of
positive examples.
Here's a negative example.
Let's put in some more
positive examples over here.

Korean: 
그냥 편미분 같은 걸
하면 됩니다
여기서 핵심은
데이터를 볼 수 있는 확률이
곡선의 형태에 달려있고
곡선의 형태는
저 매개 변수에 달려있고
이 데이터를 볼 확률을
최대화하기 위해서는
그에 맞게 매개 변수를
조정해야 합니다
데모를 보도록 하죠
좋아요
여기에 일반적인
시그모이드 곡선이 있습니다
여기에 몇 개의
양의 예시가 있습니다
여기에는 
음의 예시가 있고요
여기 양의 예시를
몇 개 더 추가해보죠

English: 
And now let's run the good,
old gradient ascent algorithm
on that.
And this is what happens.
You've seen how the
probability, as we adjust
the shape of the curve,
the probability of seeing
those examples of
the class goes up,
and the probability of seeing
the non-example goes down.
So what if we put
some more examples in?
If we put a negative
example there,
not much is going to happen.
What would happen if we put a
positive example right there?
Then we're going to start
seeing some dramatic shifts
in the shape of the curve.
So that's probably
a noise point.
But we can put some more
negative examples in there
and see how that
adjusts the curve.

Korean: 
경사 하강법(gradient ascent)
알고리즘을 적용해보죠
결과는 이렇습니다
곡선의 형태를 조정하면서
클래스의 예시를 볼 수
있는 확률이 올라갑니다
예시가 아닌 것들을
볼 수 있는 확률은 내려가죠
예시를 더 추가하면
어떻게 될까요?
음의 예시를 추가하면
큰 변화가 없습니다
양의 예시를 여기에
추가하면 어떨까요?
커브 형태에 큰
변화를 볼 수 있습니다
아마도 이게 노이즈 포인트
(noise point) 입니다
여기 음의 예시를
몇 개 더 추가하면
커브가 어떻게
조정되는지 봅시다

Korean: 
좋습니다
이게 우리가
하는 일입니다
우리는 이 출력값을
클래스를 볼 수 있는
확률에 연관 짓고 있습니다
출력층의 매개 변수를
조정하여
우리가 가진 샘플 데이터의
확률을 높입니다
그렇죠?
하나 더 있습니다
우리가 가지고 있는 게
역전파(back propagation)에
대한 개념인데
층들과 층들의
중첩되었다고 표현할게요
중첩된 층의
다음 개념입니다
여기 출력값이 있습니다
결국에는 이것도 함수고
값을 가지고 있습니다
1000개의 클래스를
가지고 있다면
1000개의 출력 뉴련을
가지게 되겠죠
각각은 어떠한 값을
생성하게 될 겁니다

English: 
All right.
So that's what we're doing.
We're viewing this
output value as something
that's related to the
probability of seeing a class.
And we're adjusting the
parameters on that output layer
so as to maximize the
probability of the sample data
that we've got at hand.
Right?
Now, there's one more thing.
Because see what
we've got here is
we've got the basic idea
of back propagation, which
has layers and layers
of additional--
let me be flattering and call
them ideas layered on top.
So here's the next idea
that's layered on top.
So we've got an
output value here.
And it's a function after
all, and it's got a value.
And if we have
1,000 classes, we're
going to have 1,000
output neurons,
and each is going to be
producing some kind of value.

Korean: 
그 값을 확률이라고
생각하면 됩니다
아직 확률을 여기에
적고 싶진 않네요
이 출력 뉴런이 가진 것은
클래스 1 (C1)의 함수입니다
다른 출력 뉴련은
클래스 2 (C2)의 함수이죠
만약 우리가 C1을 보고 있다면
이 값이 크겠고
우리가 Cn을 보고 있다면
이 값이 크겠죠
우리는 무작정 
출력값 하나를 뽑아서
제일 높은 값을 뽑았으니까
네가 이겼어
하고 끝내고 싶지 않다는 거죠
대신에 우리가 하고자
하는 것은
우리는 각 클래스의
확률에 대해 연관 짓고 싶어요
그러면 마지막에
가장 좋은 다섯 개 뽑기
같은 걸 할 수 있거든요
그럼 우리가 할 일은
P(C1)의 실제 값은

English: 
And we can think of that
value as a probability.
But I didn't want to
write a probability yet.
I just want to say
that what we've
got for this output neuron
is a function of class 1.
And then there will be
another output neuron,
which is a function of class 2.
And these values will
be presumably higher--
this will be higher if we are,
in fact, looking at class 1.
And this one down here
will be, in fact, higher
if we're looking at class m.
So what we would like to do
is we'd like to not just pick
one of these outputs
and say, well, you've
got the highest
value, so you win.
What we want to do
instead is we want
to associate some
kind of probability
with each of the classes.
Because, after all,
we want to do things
like find the most
probable five.
So what we do is
we say, all right,
so the actual
probability of class 1

English: 
is equal to the output of
that sigmoid function divided
by the sum over all functions.
So that takes all of
that entire output vector
and converts each output
value into a probability.
So when we used that
sigmoid function,
we did it with the
view toward thinking
about that as a probability.
And in fact, we assumed
it was a probability when
we made this argument.
But in the end,
there's an output
for each of those classes.
And so what we get is, in the
end, not exactly a probability
until we divide by a
normalizing factor.
So this, by the way, is called--
not on my list of things,
but it soon will be.
Since we're not talking
about taking the maximum

Korean: 
시그모이드 함수의
출력값을
모든 함수의 합으로
나눈 것과 같습니다
그래서 모든 출력 
벡터 값을
각각 확률로 바꾸는 거예요
이 시그모이드 함수를 
사용하면
이걸 확률로 보는
관점으로 풀어나갔죠
사실 이 논점을 재기할 때
그렇게 추정했었죠
결국엔 각각 클래스에
대해 출력값이 있고
우리가 마지막에
가진 값은 사실
정규화하기 전까지
확률이라 보기 어려워요
이건 아직 제 목록에는 없지만
곧 올라갈 겁니다
여기서 우리는
최댓값을 사용하여

English: 
and using that to classify the
picture, what we're going to do
is we're going to use
what's called softmax.
So we're going to give a
range of classifications,
and we're going to associate
a probability with each.
And that's what you saw
in all of those samples.
You saw, yes, this is
[? containership, ?]
but maybe it's also this,
that, or a third, or fourth,
and fifth thing.
So that is a pretty good
summary of the kinds
of things that are involved.
But now we've got one more
step, because what we can do now
is we can take this output
layer idea, this softmax idea,
and we can put them together
with the autocoding idea.
So we've trained
just a layer up.
And now we're going to detach
it from the output layer
but retain those
weights that connect
the input to the hidden layer.

Korean: 
사진을 분류하지 않고
Softmax를 사용할 겁니다
분류의 범위를 제공하고
각각의 확률을
연관 지을 것입니다
그게 전체 샘플에서
여러분이 본 거예요
여러분은 딱 보고
컨테이너 선이라고 할 수 있겠지만
그런데 사실은 2,3,4,5번째값이
될 수도 있는 거거든요
그게 꽤 알맞는
요약이라 볼 수 있겠네요
그런데 과정 하나가
더 남았습니다
이제 우리는 이 출력층 아이디어,
바로 Softmax 아이디어를
자동 코딩 아이디어와
합치면 됩니다
중간에 층을 학습시키고
출력층에서 분리시킵니다
입력값과 은닉층을 연결하는
가중치는 유지한 채로 말이죠

Korean: 
이렇게 하면
이런 결과를
볼 수 있습니다
이제 첫 번째 층을
학습시킵니다
출력층 말고요
입력층은 고정시키고
시그모이드 곡선으로
출력층을 학습시킵니다
그럼 어떤 결과가
나오는지 봅시다
먼저 테스트 샘플을
한번 돌려 봅시다
아무것도 하지
않고 있네요
출력값은 각
카테고리의 반절입니다
이미 학습된 중간 층을
가지고 있긴 하지만요
그래서 외층 또한
학습시켜야 합니다
얼마나 걸리는지
한번 봅시다
와 꽤 빠르네요
출력값과 목푯값이
굉장히 매치가 잘 되네요
이게 바로 자동 코딩과
softmax의 합작입니다
여기 언급할 만한
아이디어가 하나 더 있어요
드롭 아웃(drop-out) 
이라는 겁니다

English: 
And when we do that,
what we're going to see
is something that
looks like this.
And now we've got a
trained first layer
but an untrained output layer.
We're going to freeze
the input layer
and train the output layer
using the sigmoid curve
and see what happens
when we do that.
Oh, by the way, let's run
our test samples through.
You can see it's
not doing anything,
and the output is half
for each of the categories
even though we've got
a trained middle layer.
So we have to train
the outer layer.
Let's see how long it takes.
Whoa, that was pretty fast.
Now there's an extraordinarily
good match between the outputs
and the desired outputs.
So that's the combination
of the autocoding
idea and the softmax idea.
[? There's ?] just one more
idea that's worthy of mention,
and that's the idea of dropout.

Korean: 
신경망의 골칫거리는
지역 최댓값에
붙잡혀 있다는 겁니다
학습이 더 잘 된다는 걸
발견했습니다
매번 뉴런에 대해
동전을 던져 결정한다면 말이죠
만약 뒷면이 나오면
출력값에 아무런 영향을
끼치지 않는다고 가정합니다
뉴런을 드롭 아웃
하는 거죠
그리고 다음 반복 시에
다른 세트를 드롭 아웃합니다
그럼 이건 지역 최댓값이
고정되어 있는 걸 방지합니다
그게 심층 신경망입니다
넓은 신경망이라고
불렸어야 해요
얘네는 너비가
엄청 넓은데

English: 
The plague of any neural
net is that it gets stuck
in some kind of local maximum.
So it was discovered
that these things train
better if, on every
iteration, you
flip a coin for each neuron.
And if the coin
ends up tails, you
assume it's just died and has
no influence on the output.
It's called dropping
out those neurons.
And in our next iteration,
you drop out a different set.
So what this seems
to do is it seems
to prevent this thing from going
into a frozen local maximum
state.
So that's deep nets.
They should be called, by the
way, wide nets because they
tend to be enormously
wide but rarely

English: 
more than 10 columns deep.
Now, let's see, where
to go from here?
Maybe what we should do is talk
about the awesome curiosity
in the current state of the art.
And that is that
all of [? this ?]
sophistication with output
layers that are probabilities
and training using autocoding
or Boltzmann machines,
it doesn't seem to help much
relative to plain, old back
propagation.
So back propagation
with a convolutional net
seems to do just about
as good as anything.
And while we're on the subject
of an ordinary deep net,
I'd like to examine
a situation here
where we have a deep net--
well, it's a classroom deep net.

Korean: 
10개 열 이상
깊지는 않거든요
그럼 여기서
뭘 더 해야 할까요?
최신 기술에 대한 엄청난 것들에 대해
이야기해 볼까요?
그건
확률값인 출력층의 세련됨과
자동 코딩이나 볼츠만 머신을
이용하여 학습하는 것은
별로 큰 도움이 
되는 것 같지 않아요
역전파 방법과 
비교해서 말입니다
합성곱 신경망에서
역전파는 유익합니다
일반적인 심층 신경망에서는
이 상황을 좀 더
자세히 보고 싶습니다
이건 수업 시간용
심층 신경망입니다

Korean: 
여기에 다섯 개의
층을 쌓을 건데
결국은 똑같은
일을 합니다
동물이 치타인지, 얼룩말인지
아니면 기린인지 구분합니다
그림자의 크기에
따라서 말이죠
아까와 같이
초록색이면 양이고
빨간색이면 음입니다
지금 당장은
학습 시키지 않은 상태입니다
테스트 샘플을 돌리면
동물 분류에 상관없이
결과 값은 1/2 입니다
그렇죠?
그래서 우리는
역전파를 사용할 거예요
저 칠판 밑의 샘플과
똑같은 겁니다
매개 변수가
더 많아졌을 뿐입니다
총 다섯 개의 열이 있고
각각 9~10개의
뉴런을 포함합니다
이걸 한번 돌려봅시다
오른쪽을 보세요
다 빨간색으로 바뀌었어요

English: 
And we'll will put
five layers in there,
and its job is still
to do the same thing.
It's to classify an animal as a
cheetah, a zebra, or a giraffe
based on the height of
the shadow it casts.
And as before, if it's
green, that means positive.
If it's red, that
means negative.
And right at the moment,
we have no training.
So if we run our
test samples through,
the output is always a 1/2
no matter what the animal is.
All right?
So what we're
going to do is just
going to use ordinary back
prop on this, same thing
as in that sample that's
underneath the blackboard.
Only now we've got a
lot more parameters.
We've got five columns,
and each one of them
has 9 or 10 neurons in it.
So let's let this one run.
Now, look at that
stuff on the right.
It's all turned red.

English: 
At first I thought this
was a bug in my program.
But that makes absolute sense.
If you don't know what the
actual animal is going to be
and there are a whole
bunch of possibilities,
you better just say
no for everybody.
It's like when a biologist
says, we don't know.
It's the most probable answer.
Well, but eventually, after
about 160,000 iterations,
it seems to have got it.
Let's run the test
samples through.
Now it's doing great.
Let's do it again just to
see if this is a fluke.
And all red on the right
side, and finally, you
start seeing some changes go
in the final layers there.
And if you look at the error
rate down at the bottom,

Korean: 
처음에 전 이게
프로그램 버그인 줄 알았어요
그런데 말이 되는 겁니다
동물이 뭐가 될지 모르고
아주 많은 경우의 
수가 있다면
모든 게 아니라고
하는 게 나을 수 있어요
생물학자들이
자기도 모른다고 하는 것처럼요
가장 그럴듯한 답이죠
그렇지만 160,000번의
반복 끝에
답이 나온 것 같군요
테스트 샘플을 한번
돌려봅시다
아주 좋아요
이게 우연이었는지
다시 한번 돌려봅시다
오른쪽은 완전 빨갛네요
마지막 층에 변화가
보이기 시작합니다
밑에 에러율을 보면

Korean: 
급격하게 떨어지는
걸 볼 수 있습니다
아주 오랫동안
아무 일도 일어나지 않다가
급격한 변화가 생겨요
만약 신경망의 너비가
넓지 않았다면 어땠을까요?
좋은 질문입니다
그 질문으로 넘어가기 전에
드롭 아웃에 대해
재밌는 변형을 해볼게요
각 열에서 뉴런 하나씩만
죽일 겁니다
그리고 네트워크를
다시 학습시킵니다
다른 목적으로
재배정을 하고
이제 네트워크에
뉴런 하나가 적어졌어요
다시 학습시키면
매우 빨라진다는 걸 알 수 있어요
그래도 정답에
꽤나 가깝습니다
각 열에서 뉴런 
하나씩을 없애더라도요
다시 한번 해보죠
조금 올라갔다가
다시 정답으로 돌아오네요

English: 
you'll see that it kind
of falls off a cliff.
So nothing happens
for a real long time,
and then it falls off a cliff.
Now, what would happen if
this neural net were not
quite so wide?
Good question.
But before we get to that
question, what I'm going to do
is I'm going to do a
funny kind of variation
on the theme of dropout.
What I'm going to
do is I'm going
to kill off one
neuron in each column,
and then see if I can
retrain the network
to do the right thing.
So I'm going to reassign
those to some other purpose.
So now there's one fewer
neuron in the network.
If we rerun that, we see that
it trains itself up very fast.
So we seem to be
still close enough
to a solution we
can do without one
of the neurons in each column.
Let's do it again.
Now it goes up a little
bit, but it quickly
falls down to a solution.

Korean: 
다시 한번 해봅니다
다시 빠르게 돌아옵니다
도대체 이걸
몇 번이나 해야 하죠?
매번 무언가를 지우고
다시 학습시킬 때마다
답안을 더 빠르게
찾고 있습니다
각 열에 뉴런이 2개
남을 때까지 왔어요
그런데도 답이 나옵니다
흥미롭지 않나요?
실험을 다시 한번
해봅시다
이번에는 약간
다른 방법을 써볼 겁니다
다섯 개의 층을 가지고
아무것도 학습시키지
않은 상태에서
각 열에서 두 개의 뉴런을 제외하고
모두 버릴 겁니다
각 열에 뉴런이 2개 씩
있다는 걸 알고 있어요

English: 
Try again.
Quickly falls down
to a solution.
Oh, my god, how much of
this am I going to do?
Each time I knock
something out and retrain,
it finds its solution very fast.
Whoa, I got it all the way down
to two neurons in each column,
and it still has a solution.
It's interesting,
don't you think?
But let's repeat the
experiment, but this time we're
going to do it a
little differently.
We're going to take
our five layers,
and before we do
any training I'm
going to knock out all but
two neurons in each column.
Now, I know that with two
neurons in each column,

Korean: 
저는 답안을 얻었습니다
방금 보여드렸죠
방금 하나 보여드렸어요
그렇지만 이 방법으로
다시 돌려볼게요
가면 갈수록
좋지 않아 보이는 데요
지역 최댓값에
얽매여 있습니다
왜 신경망 학습에
돌파구가 있는지 알겠죠?
신경망을 넓히면
지역 최댓값을 안장점(saddle
point)으로 바꿀 수 있습니다
이제 지역 최댓값에 얽매이지 않고
기어갈 공간이 넓어졌습니다
여기서 제안한 것처럼요
좋아요
짚고 넘어가기에
흥미로운 내용이었습니다

English: 
I've got a solution.
I just showed it.
I just showed one.
But let's run it this way.
It looks like
increasingly bad news.
What's happened is that
this sucker's got itself
into a local maximum.
So now you can see
why there's been
a breakthrough in this
neural net learning stuff.
And it's because when
you widen the net,
you turn local maxima
into saddle points.
So now it's got a way
of crawling its way
through this vast
space without getting
stuck on a local maximum,
as suggested by this.
All right.
So those are some, I
think, interesting things

English: 
to look at by way of
these demonstrations.
But now I'd like to go
back to my slide set
and show you some
examples that will address
the question of whether these
things are seeing like we see.
So you can try these
examples online.
There are a variety
of websites that allow
you to put in your own picture.
And there's a cottage industry
of producing papers in journals
that fool neural nets.
So in this case, a very
small number of pixels
have been changed.
You don't see the
difference, but it's
enough to take this
particular neural net
from a high confidence that
it's looking at a school bus
to thinking that it's
not a school bus.
Those are some things that
it thinks are a school bus.
So it appears to be
the case that what

Korean: 
데모를 통해서 말입니다
다시 슬라이드로 돌아가서
얘들도 우리가 보는 것을 볼지
알아보기 위한
예시를 보여주고 싶습니다
온라인으로 직접
해볼 수 있어요
자기 사진을 넣을 수
있는 사이트가 많이 있어요
바보같은 신경망 관련 저널 논문을
출판하는 가내 공업이 있습니다
여기서는 아주 적은
픽셀이 변했습니다
변화가 눈에 보이지 않지만
그렇지만 신경망이 높은 확신으로
이 사진을 통학 버스라고 하는 것에서
확신이 떨어지게 할 만큼의
변화가 생겼습니다
저런 것들이 통학 버스라고
생각하게 하는 요인입니다

English: 
is triggering this
school bus result
is that it's seeing enough
local evidence that this is not
one of the other 999 classes
and enough positive evidence
from these local
looks to conclude
that it's a school bus.
So do you see any
of those things?
I don't.
And here you can say, OK, well,
look at that baseball one.
Yeah, that looks like it's got
a little bit of baseball texture
in it.
So maybe what it's doing
is looking at texture.
These are some examples from
a recent and very famous
paper by Google using
essentially the same ideas
to put captions on pictures.
So this, by the way,
is what has stimulated
all this enormous concern
about artificial intelligence.
Because a naive viewer looks
at that picture and says,

Korean: 
통학 버스라고 생각하게
만드는 요인은
다른 999개의 클래스가
아니라는 충분한 부분적 근거를 가지고
일부 생김새를 통해
충분한 긍정적 근거를 가지고
통학 버스라고
결론을 내리는 거죠
그럴만한 게 보이나요?
저는 보이지 않네요
여기서는 
야구공을 한번 보세요
야구공 질감 같아 보이네요
아마도 얘네들의
질감을 보나 봐요
구글이 낸 유명한 논문에서
가지고 온 예시인데
사진에 자막을 넣는 것과
비슷한 개념입니다
인공 지능에 대한 우려를
자극한 케이스인데
아무것도 모르는 사람이
저 사진을 보고

English: 
oh, my god, this
thing knows what
it's like to play, or be young,
or move, or what a Frisbee is.
And of course, it
knows none of that.
It just knows how to
label this picture.
And to the credit of the
people who wrote this paper,
they show examples
that don't do so well.
So yeah, it's a cat,
but it's not lying.
Oh, it's a little girl, but
she's not blowing bubbles.
What about this one?
[LAUGHTER]
So we've been doing our
own work in my laboratory
on some of this.
And the way the following set of
pictures was produced was this.
You take an image,
and you separate it
into a bunch of slices,
each representing
a particular frequency band.
And then you go into one
of those frequency bands
and you knock out a
rectangle from the picture,
and then you
reassemble the thing.
And if you hadn't
knocked that piece out,
when you reassemble it,
it would look exactly

Korean: 
놀이라는 게
무엇인지 아는구나
어리거나, 움직이는 거나,
프리즈비가 뭔지 아는 줄 안다는 거죠
그렇지만 어느 것도
해당되지 않습니다
사진에 어떻게 라벨을
붙이는 지만 알고 있어요
이 논문을 쓴 사람들에게
크레딧을 주기 위해서
잘 작동하지 않는
예시도 넣어놨어요
고양이이긴 하지만
누워있지는 않죠
여자 아이이긴 하지만
비눗방울을 불지 않아요
이건 어때요
(학생 웃음)
제 연구실에서
이런 걸 하고 있습니다
다음 세트의 사진은
이런 식으로 생성됩니다
사진을 여러 개의
슬라이스로 나누는데
각각은 특정한 주파수대를
대표합니다
그다음에 하나의
주파수대로 내려가서
사진에서 하나의
사각형을 빼내고
다시 모든 걸 합쳐요
만약 어떤 것도 
빼내지 않았다면

Korean: 
합쳤을 때는 
처음과 완벽하게 같겠죠
우리는 최대한 많은
걸 빼내면서도
신경망의 느낌을
유지하려고 합니다
처음부터 생각했던
방법이죠
이게 뭐라고 생각하나요?
신경망이 이걸
철도 차량이라고 했어요
이 사진으로 시작했거든요
이거는요?
이건 쉽죠
기타입니다
이 사진은 많이 훼손하지 못해서
기타 특성을 아직
많이 가지고 있습니다
이거는요?
(학생) 램프?
뭐라고요?
(학생) 램프
네?
(학생) 램프
램프요
다른 의견?
(학생)
(학생)
켄, 이게 뭐 같나요?
(학생) 화장실?
보세요 이 친구가
전문가입니다
(학생 웃음)
바벨입니다
이거는요?
(학생)
뭐라고요?
(학생) 첼로
첼로
여자 아이나
선생님은 보지 못했어요

English: 
like it did when you started.
So what we're doing is we
knock out as much as we can
and still retain the
neural net's impression
that it's the thing that it
started out thinking it was.
So what do you think this is?
It's identified by a neural
net as a railroad car
because this is the image
that it started with.
How about this one?
That's easy, right?
That's a guitar.
We weren't able to mutilate that
one very much and still retain
the guitar-ness of it.
How about this one?
AUDIENCE: A lamp?
PATRICK H. WINSTON: What's that?
AUDIENCE: Lamp.
PATRICK H. WINSTON: What?
AUDIENCE: Lamp.
PATRICK H. WINSTON: A lamp.
Any other ideas?
AUDIENCE: [INAUDIBLE].
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON: Ken,
what do you think it is?
AUDIENCE: A toilet.
PATRICK H. WINSTON: See, he's
an expert on this subject.
[LAUGHTER]
It was identified as a barbell.
What's that?
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON: A what?
AUDIENCE: Cello.
PATRICK H. WINSTON: Cello.
You didn't see the little
girl or the instructor.

English: 
How about this one?
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON: What?
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON: No.
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON:
It's a grasshopper.
What's this?
AUDIENCE: A wolf.
PATRICK H. WINSTON:
Wow, you're good.
It's actually not
a two-headed wolf.
[LAUGHTER]
It's two wolves that
are close together.
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON:
That's a bird, right?
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON:
Good for you.
It's a rabbit.
[LAUGHTER]
How about that?
[? AUDIENCE: Giraffe. ?]
PATRICK H. WINSTON:
Russian wolfhound.
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON: If
you've been to Venice,
you recognize this.
AUDIENCE: [INAUDIBLE].
PATRICK H. WINSTON:
So bottom line
is that these things
are an engineering

Korean: 
이거는요?
(학생)
네?
(학생)
아니요
(학생)
메뚜기입니다
이거는요?
늑대
와 정말 잘하네요
머리 두 개 달린
늑대는 아닙니다
(학생 웃음)
두 마리 늑대가
붙어있는 거예요
(학생)
이거 새 맞죠?
(학생)
아주 잘했어요
토끼에요
(학생 웃음)
이거는요?
(학생)
러시안 울프하운드입니다
(학생) 고양이
베니스에 가본 적이 있다면
이걸 알아볼 겁니다
(학생)
그래서 중요한 점은
이게 바로 공학의 경의로움이고
신기한 걸 해내지만

English: 
marvel and do great things,
but they don't see like we see.

Korean: 
우리가 보는 것처럼
보지 않습니다
