[EECS 498-007] Lecture 12. Recurrent Neural Networks

11강 잠시 skip후 12로 돌아온 나 

글구 12강은 또 나의 발표 순서야 

에이부터 제트까지 낯낱이 파헤처볼게 

휘낭시에 먹으면서 

넷플 볼 생각으로 집가려했는데 ...

나 웨 윙방이냐 

대충 열심히 빡공하고 집갈게 

히히 

 

아진짜미쳣냐?

왜자꾸 억까하지

발표날 블로그만 자꾸 이놈색키가

저장안해주고 통으로 들튀한다고

진짜 어제 하루를 갈아넣은 나의 50페이지가

없어졋어.................................

살고십지안아...................

---

이번 강은 흔히 RNN이라고 말하는! 

Recurrent Neural Networks에 대해서 다루어 볼 것 입니다. 

 

먼저 지지지난강의에서 

pytorch에서 TPUs를 사용할 수 없고 mobile용으로 개발하기 어렵다는 점을 단점으로 언급했었다. 

(사실 9강에서도 언급했는지는 모르겠지만, google colab의 등장으로 pytorch도 현재는 TPU를 사용할 수 있음!)

그런데 pytorch 1.3이 나온 후에는 torch-xla라는 패키지를 사용하면 TPU를 지원해준다. 또한 Pytroch mobile 프레임워크를 사용하면 학습된 모델을 스마트폰에서 동작시킬 수 있다고 한다. 

 

@본론@ 

지금까지 배웠던 CNN은 Feedforward Neural Networks라고 통칭할 수 있다.

- One to One

예를 들어, 또 한 single image가 input으로 들어가면 leble을 return하는, one to one 구조였으며 우리가 layer를 많이 쌓느냐에 따라서 딥러닝이다! 라고 이야기 했었다. 

• Image classification 

 

- One to Many

그런데 하나의 input으로 많은 output을 내야하는 경우에 process sequences를 거치게 된다. 그러한 경우를 예로 들면 

• Image Captioning
  
  • input image -> sequence of words 
  • 기계가 시각적 정보를 이해하고 그에 대해 자연어로 설명하는 것. 
  • CNN을 사용하여 입력 이미지의 특징 추출 -> 특징을 기반으로 RNN을 통해 문장 생성 

 

- Many to One

또한 여러 개의 input이 들어가서 하나의 output을 내는 경우! 

• Video classification 
  • sequence of images (여러 개의 이미지 프레임이 들어가는 것과 같음, 비디오!) -> lable (이건 야구 or 축구 등의 영상이야!

 

- Many to Many

여러 개의 Input이 들어가서 여러 개의 output이 나오는 경우!

• Machine Translation 
  • Sequence of words -> Sequence of words
  • 앞의 형태와 달리 input과 다른 형태의 모양을 만들어 낸다. 

 

-Many to Many

여러 개의 input이 들어가서 여러 개의 output이 나오는 경우 

• per-frame video classification 
  • sequence of images -> sequence of labels
  • 매 frame마다 적절한 액션이나 어떤 class의 결과를 출력하는 것

Sequecntial processing of Non-Sequential Data 

비순차적 데이터에 대해 순차적 처리를 하기 위해서 RNN을 사용하는 경우! 

-many to one

glimpses : 어떤 대상의 일부를 간략하게 볼 수 있는 작은 조각이나 순간! 

부분(glimpses)을 가져와서 classifiy를 하는 것! 

이미지의 어떤 부분을 보는 지를 시간 단위로 확인하여 label하는 것! 어떻게 보면 many to one에 해당함

 

근데 시작위치는 어케 정해?

몰루? -> 보통 무작위로 정한다고 합니다. 

 

- ont to many 

순차적인 처리를 통해 image를 generation 하는 것! 

 

이미지 한 장을 주고 그것을 그릴 수 있는 oil paint simulator로 실제로 stroke의 output들을 만들어 내는 것이다. 

결국 입력된 이미지를 가장 잘 표현하는 stroke을 생성해 내는 것

 

위와 같은 것들을 효과적으로 하기 위해서! recurrent neural networks를 사용할거야!

 

RNN

x라는 input이 들어가고 y라는 output이 나올 때, 이전의 input과 output의 영향을 받아 원하는 시점의 출력을 낼 수 있게 해주는 것이다. 

RNN에는 Internal state, 즉 hidden state라고 하는 것이 존재한다. 이는 전의 입력이 연속적으로 들어오면 hidden state가 업데이트 되어 그것에 맞는 output을 낼 수 있도록 해준다. 

 

이를 수학적으로 작성해보면 다음과 같을 수 있다.

• 빨간색 상자 : time t 에서의 input vector x!
• 초록색 상자 : 직전의 시간, t-1에서의 hidden state
• 보라색 상자 : ht-1과 xt의 조합으로 이루어진 어떤 함수, learnable parameter인 W와 함께 사용됨 
  • 여기서 W는 모든 time step에서 같은 func과 같은 parameter의 set을 사용한다! 하나의 W로 네트워크를 만들어 놓는 것!  
    • 왜?
    • 냐면 RNN에서 서로 다른 시간 단계에서 다른 함수와 W를 사용하게 된다면 시간에 따른 패턴을 찾는 것이 어려워질 것이다. 따라서 항상 동일한 것들을 사용함으로써 이전 단계에서 학습한 정보 기억하고 현재 단계로 전달하여 시간에 따른 의존성 모델링을 할 수 있는 것이다. 
• 파란색 상자 : fw를 적용시켜 나오는 t에 대한 새로운 hidden state

그렇다면 기초적인 표준 RNN인 Vanilla RNN을 살펴보자

위에서 보았던 fw의 함수를 더 자세히 뜯어보면(?)

ht-1은 Whh와 같은 matrix와 곱해주고, xt에는 Wxt인 matrix를 곱한 값과 합하여 tanh를 거쳐 nonlinearity를 부여해준다. 그래서 나온 그 값이 새로운 hidden state인 ht가 되는 것이다. 

그 ht에다가 Why라는 matrix를 곱해 yt라는 output을 구해주고 있다. 

등장하는 3개의 matrix가 우리가 학습해야하는 learnable prarameter라고 할 수 있다. 

 

이것을 computatinal graph로 나타내보면, 

처음 initial hidden state(h0)는 모든 값이 0이도록 초기화를 하거나, learnable parameter로 생각해서 학습을 시킬 수도 있다. 

h0을 정의를 한 뒤, input x1과 h0의 조합으로 fw라는 함수를 적용시켜서 새로운 hidden state h1을 만들어낸다. 

위와 같이 동일한 function과 동일한 W로 과정을 반복한다면 아래와 같이 나타날 것이다. 

RNN이 many to many일 경우에는 

위와 같이 x1, x2 ...이 Input으로 들어갔을 때, Output도 y1, y2 .. yt까지 생성될 것이다. 

그 후에 각 해당되는 output마다 loss를 계산하여 합한 뒤 global loss(?)를 구할 수 있게 되는 것이다. 

 

만약 many to one의 경우라면

위와 같은 형태가 될 것이다. 지금까지 진행된 sequence를 다 보고! 하나의 output y를 도출해내는 방식이다. 

 

또는 one to many의 경우는 다음과 같이 나타낼 수 있겠다. 

하나의 Input x가 들어왔다면, image captioning 처럼 y1, y2.. yt까지의 output을 내는 구조이다. 

 

또!는! seq2seq인 구조가 있는데, 이는 Many to one + One to many의 형태이다.

굳이 이처럼 구현하는 이유는 앞에서 보았던 many to many의 구조는 input의 개수와 output의 개수가 동일하였다. 

하지만 english to french를 하게되면, 영어 문장에서의 단어 개수와 불어의 단어개수는 달라질 것이다. 따라서 이러한 경우에 위와 같은 구조를 사용하는데, 

• Encode (Many to one) : input sequence를 가지고 하나의 single vector를 만들어 낸다. 
• Decode (One to many) : 만들어진 single vector를 input이 되어 output sequence를 만들어 낸다. 나온 output이 다음 디코더의 입력 값으로 사용된다. 

---

📌 근데 공부를 하다보니 궁금했던 점!

decoder가 올바르지 못한 output을 내뱉을 때, 다음 input으로 들어간다면 그 뒤는 다 망하지 않나?

그런 점을 해결하기 위해 Teacher Forcing! 이라는 친구가 등장했더라구요!

• Teacher Forcing 

• 위와 같이 output이 잘못 나와도 다시 올바른 입력으로 넣어주면 더 정확한 예측이 가능해질 것! 
• 초기 학습 속도를 올릴 수 있어 효율적으로 training을 할 수 있다. 

• 하지만 추론 과정에서는 정답값을 제공해 줄 수 없기에 출력값을 기반하여 예측을 이어나가야 한다는 단점 
  
  • 근데 그치만 2019년에 새로 나온 논문에서 그렇게 노출 편향 문제가 크지 않다고 말해줬댕

---

예를 보면 Language Modeling이 있다. 

미리 글자가 t개가 주어져 있고, "hello"라는 것을 학습을 한다고 가정을 해보자. 

input은 우리가 각 해당하는 글자마다 one-hot-encoding을 적용해서 h : [1, 0, 0, 0]과 같이 vector 형태가 된다. 

처음 경우만 살펴본다면, "h"일때, 즉 input vector xt가 [1, 0, 0, 0]이면 Wxh의 matrix의 곱과

이전 hidden state인 h0 (현재 여기서는 0으로 설정된 것 같아요)과 Whh의 곱의 합에 tanh를 적용시키면 새로운 hidden layer h1인 

[0.3, -0.1, 0.9]가 생성되는 것이다. 

그렇게 생성된 각각의 h에 대해서 output을 만들어 낼 수가 있는데, 우리는 input "h"가 들어갔을 때 output으로 "e"가 나오길 바란다. 

따라서 [0, 1, 0, 0]이 나오고 싶은데! [1.0, 2.2, -3.0, 4.1]이 나왔다. 각 output마다 그것의 loss를 계산하고 그 loss를 우리가 역으로 적용시켜서 Whh, Why, Wxh를 업데이트 시켜나가는 것이다. 

이때 loss는 cross entropy loss를 사용한다고 한다. 

따라서 위와 같이 학습을 시켜 나가는 것을 볼 수 있다.  

 

 

이를 test할 때는 어떻게 할 것인가!

우리가 입력을 "h"만 주면, "e"가 나오고 그 "e"가 또 다음 input이 되고 이 과정을 반복하여

---

📌근데 내가 또 이 과정에서 궁금했던 점! 

지금은 test!인데 softmax후 나온 값에서 가장 큰 값은 0.84로 즉 해당 task에서는 'o'가 출력되어야지! 왜 e지? "sample"? 이 몰까

-> sampling! 

• samplig
  • softmax후에 바로 argmax를 취해서 가장 높은 값을 뽑는 것이 아닌, 주변의 값들도 보고 sampling된 값을 뽑는 것이다. 
  • sampling 방식 들에는 random sampling, importance sampling 등 .. . 등 이 있을 것 같우

---

 

 

위와 같은 구조를 보게될 것이다. 즉 input "h"만 넣어주면 자동으로 "hello"를 출력해주는 것이다. 

근데 우리가 지금까지 input을 one-hot-encoding된 vector를 사용하였다. 근데 이 vector는 W_xh와 곱해지는데, 이 경우에 위의 그림을 참고하자면 항상 특정 colum에 대해서만 결과가 나온다. 

이러한 메커니즘을 이용하여 embedding layer를 만들어서 사용하면 훨씬 효율적일 것이다!

• Embedding 이란! 
  • 이산적 데이터, 주로 단어나 토큰 같은 것을 저차원의 연속 벡터로 변환하는 것 
  • 임베딩은 단어 간의 의미적 유사성을 보존하도록 학습됨 
  • 저차원의 밀집 벡터로 변환돼 계산량과 메모리 측면에서 보다 효율적 

이제는 backprop을 해야해 어떻게 하까! 

우리가 forward연산을 통해 전체 sequence에 대해서 loss를 계산했다. 하지만 이를 backprop을 한다고 생각해봐! 

굉장히 long 한 sequence인데.. 엄청나게 많은 메모리가 필요한 것이 문제가 된다고 한다. 

 

그래서 너무 long해지는 것을 막기위해 Truncated Backprop을 제안하는데 

이는 얼마만큼씩 끊어서 chunks 단위로 forward를 통해 Loss를 계산하고, backward를 통해 가중치를 update해가는 방식이다. 

 

forward의 경우 chunk가 달라지면 그 전에 있던 최종적인 hidden state를 가지고와서 다음 chunk의 초기 hidden state로  문제없이 연산을 해 나간다. 영원히 가능! 

그치만 backward의 경우, 그 전의 chunk에서 update를 할 수 없기에 그 덩어리 안에서만 backward계산을 해 나가는 방식이다. 

 

지금까지 배운 내용을 파이썬 코드로 작성한 것이 아래와 같다. 

아래는 윌리엄 쉐익스피어가 쓴 시집이다. 

이를 RNN에 적용시켜 보았는데, 

랜덤하게 초기화가 되어있으면 처음에는 문장의 구조조차 잘 안잡혀있던 반면, 

train을 더 하니 단어들이 모양새를 갖추기 시작했다. 

완전히 train을 끝낸 후에는 단어나 문장의 문제가 쉐익스피어와 비슷해지는 것을 볼 수 있다. 

 

이러한 것을 가지고 여러가지 task를 진행해 보았는데, Latex source를 가지고 학습을 시킨 뒤,

실제로 의미가 있는 형태는 아니지만 전체적으로 수학적 기호 및 문체 등이 자연스럽게 생성되어 latex 문법에 맞게 갖추어진 구조를 볼 수 있다. 

 

또한 linux의 kenal source인 C source를 학습을 시켜 generation 해보니까 

다양한 C의 operate를 사용한 것을 볼 수 있다. 이러한 코드가 실행시켜 의미있는 값을 도출하진 않지만 하지만 이런식의 C언어의 모듈들과 헤더파일, 매크로 등등의 형태들을 유지하는 RNN의 파워를 볼 수 있겠다. 

 

그럼 RNN의 어떤 것때문에 이런게 가능할까?

결국은 hidden state의 특정한 node가 어떤 것의 structure를 학습하기 때문이라고 할 수 있다. 

위는 input이 하나 들어가면 그에 대한 output이 generation되면서 hidden state가 바뀌는데, tanh함수를 적용시켜서 -1 부터 1 사이의 값이 출력되도록 만들었다. 따라서 그 안의 특정 node의 값이 1에 가까우면 빨간색, -1에 가까우면 파란색으로 해서 가시화를 해본 것이다. 이런 특징(?)을 사용해서 다양한 task를 진행할 수 있는데 

• quote detection cell 

"" -> 따옴표를 detection하는 것인데 따옴표가 시작되면 node의 특정 값이 마이너스 값이 되다가 따옴표가 마쳐지면 다시 positive한 값으로 바뀌어 빨간색으로 바뀌는 것을 알 수 있다. 

• line length tracking cell 

다음은 처음 시작할 때는 파란색이었다가 뒤 쪽으로 갈수록 빨간색으로 바뀌는 것을 볼 수 있다. line에 어느 위치에 있는가에 대해서 

sensitive하게 cell을 찾아 80자 이상이 되면 줄을 바꿔주는 task를 해결할 수 있다. 

 

• if statement cell

다음은 if문을 detection하는 것인데, if문에서 중괄호가 시작이 되는 곳까지가 빨간색으로 표현하여 nested된 if문까지도 잘 표현하는 

그러한 cell들이 있는 것이다. 

• quote/comment cell

위와 같은 경우도 어떤 주석처리가 시작되면 빨간색, 끝나면 다시 파란색으로 바뀌며 인용구 같은 경우에도 위와 같은 형태로 표현된다. 

 

• code depth cell

또한 indentation의 깊이가 깊어질수록 중요도를 높여 많이 들어가면 값이 점점 빨갛게 되고, 그렇지 않을 때는 파란색으로 주어 

code의 depth에 따라서 node의 값을 변화하고 있다. 

 

위와 같은 것들이 RNN에서 hidden unit의 특정 cell들이 특정 입력에 학습되어 중요한 정보들을 내부적으로 저장되는 구조로 이루어져 있던 것이다. 

 

지금까지는 laguage에 대한 모델이었다. image에 대해서 살펴보자! 

위 사진과 같은 입력 image가 들어어면 "straw(밀집)", "hat(모자)"와 같이 output을 내는, image captioning을 하는 것이므로

one to many의 구조이다. 

• image의 feature들을 잘 뽑을 수 있는 CNN의 과정을 거친 후, 
• CNN을 거쳐서 나온 feature vector를 새로운 추가적인 hidden state의 입력으로 넣은 뒤
• 원래 입력과 이미지의 feature vector를 가지고 hidden state를 업데이트 후 output을 낸다 

결론은 CNN을 통해 이미지의 정보들 중 의미있는 정보를 뽑아내고, RNN을 통해 captioning을 진행하자! 이다. 

 

Transfer learning

이미 pretrain된 모델이 있으면, 가장 마지막 부분에서 진행되는 class labeling 작업을 하지 않고 그 직전에 있는 의미있는 featrue vector를 사용하자! 가 transfer learning이다. 

그래서 두번째 사진을 보면 그 feature vector가 RNN의 처음 input이 되는 것을 볼 수 있다.

 

여기서 조금 다른 것은

전에는 hidden state를 input x와 그 전의 hidden state의 조합으로 구했다. 

하지만 지금은 이미지의 해당되는 feature를 v라고 하면 Wih 라는 이미지에 대한 matrix와 v의 곱의 형태가 더 추가가 되었다. 

 

생성되는 모든 hidden state에 동일하게 matrix Wih가 연산에 적용된다. 

다음 특정한 <END>라는 토큰을 생성해내면 멈추게 되는 구조로 되어있다. 위와 같은 과정으로 진행된 image captioning의 예시를 살펴보면

위와 같다. 이미지에 대한 text를 generation한 예시인데, 물로 두번째 사진과 같이 failure case도 존재한다. 

 

왜 실패할까?

• Diversity(다의성) : 이미지는 매우 다양하고, 동일한 컨셉이라도 다양한 형태로 나타날 수 있다. 
• 데이터의 부족 : 적절한 캡션을 생성하려면 다양한 train data가 필요한 것은 당연하다! 

Vanilla RNN Gradient Flow 

 

 

: 입력 xt와 직전의 hidden state인 ht-1을 합쳐서 하나의 vector인 stack을 만든다

 

 

 

: 여기서 말하는 W는 (Whh Whx)를 말한다. 

 

 

 

: 위에서 구한 stack과 W를 곱한 뒤 tanh를 씌워 ht인 새로운 hidden state를 구하는 것이다. 

 

 

여기서 중요한 것은 W를 학습을 시켜야 한다는 것이다! -> backpropagation을 해야겠다! 

ht에서 역으로 tanh를 적용시켜야 하는데 아주 복잡한 형태의 식이 나온다. 

그래서 문제야! nonlinearity에 backprop을 적용시키려면 너무 어려워!!! 

그리고 또 입력 시퀀스가 위와같이 길어진다면 loss에 대한 gradient를 가지고 backprop을 진행할 때, W가 계속 곱해져서 엄청난 곱셈량과 함께 h0의 gradient를 구하게 된다. tanh에도 동일하겠지!

 

그래서

• 가장 큰 singular value(W를 말하는건가) > 1 =>  뒤에서 gradient가 엄청나게 커져버리는 Exploding gradient현상 발생 
• 가장 큰 singular value < 1 => gradient가 결국 작아지는 vanishing gradient의 현상 발생

-> 해결해야겠지

 

- 큰 경우에는 

• gradient clipping을 진행한다. 
  • norm의 크기가 너무 큰 경우에 gradient의 scale을 조정하여 적용 -> 많이 커지지 않고 유지되는 효과

- 작은 경우에는 

• Change RNN 
  • RNN말고 다른 아키텍처로 교체해야한다!

--> 위와같이 RNN은 시간이 흐름에 따라 gradient가 손실되거나 폭발할 수 있는 문제가 있으므로 이전의 시간 단계의 정보를 반영하기 위한, 즉 장기의존성 문제에 대한 대응이 어렵게된다. 결국 시퀀스 길이가 길어질수록 먼 과거의 정보를 기억하는데에 어려움을 겪는 것이다. 

 

LSTM 

-> long term dependency(장기의존성)의 문제를 해결하기 위해서 둥장 

 

(근데 여기서 본 강의자료 말고! 다른 자료로 LSTM을 이해한 후 다시 넘어와보겠습니당)

 

RNN

위 그림이 우리가 원래 알던 RNN의 구조이다. 

실제로 우리는 위위의 그림 하나를 오른쪽과 같이 computational graph로 나타내보면 recurrent의 형태를 의미하는 것으로 이해할 수 있었다. 하지만 위에서 언급했듯 RNN에는 문제가 있었는데, 

위와 같이 x0, x1에 대한 정보가 ht+1까지 전달이 되어야 하는데 그렇지 못하는 경우가 있는 문제가 있다. -> LSTM 등장 

LSTM

LSTM은 위와 같이 4개의 interating layers가 포함되어 있는데,

그림에서 각 요소는 위와 같은 뜻을 의미하고 있다. 핵심아이디어는 위에 컨베이어 벨트처럼 추가된 cell state의 존재(?)인데,

나중에 써먹어야 하는 꼭 중요한 정보라면! keep 해뒀다가 나중에 꺼내 써먹자 하는 역할을 해준다. 즉 특정한 정보가 변화되지않고 쭉 

flow를 따라갈 수 있도록 해주는 것이다.

cell state

위 그림에서 보이는 C가 cell state를 의미하는데, Ct-1 에서 Ct로 가기위해 최소한의 연산! vector 연산도 아니고, nonlinearity도 없는

pointwise연산만을 통하여 구성되어 있다. 

 

결국 LSTM은 이 cell state의 얼마나 많은 정보를 제거하고, 추가할 것인가에 따라 결정되는데, 정보를 얼마나 많이 제거하고 추가할 것인가! 는 gate라는 녀석이 등장하여 제어하게 된다. 

gate

위와 같이 sigmoid라는 Gate(?)가 있다면, 그 시그모이드의 값이 곱하기라는 pointwise연산에 영향을 주는 것이다.

sigmoid함수는 0과 1사이의 값들로 이루어져 있다. 예를 들어 0이라면 Ct-1에서 Ct로 갈 때에 Ct-1의 값은 Ct에 전혀 영향을 주지 않아 제거되는 형태가 되고, 값이 1이라면 전부를 영향을 주는 정보가 될 것이다. 

 

--> 결국 gate는! sigmoid neural net layer와 pointwise multiplication으로 구성되어 있다. 

 

정리하자면

1) cell state로 부터 얼만큼 정보들을 유지, 삭제할 것인가를 결정하기 위한 "forget gate layer"를 정의한다 

 * forget gate는 직전의 layer (ht-1)과 입력 Xt의 조합으로 정의되는데,

위와 같은 사진과 같다. 결국 오른쪽의 식으로 구해진 ft가 cell state인 Ct-1과 곱해지는 것이다. 

 

2) 새로운 정보를 저장하기 위한, "input gate layer"를 정의한다. 

직전의 hidden state인 ht-1과 input Xt의 조합으로 tanh를 거쳐

  *tanh를 거친다는것은 다 neural networks기 때문에 learnable parameter인 W와 bias의 곱과 합으로 계산된 뒤 tanh를 적용시킨다는것 

새로운 cell state를 만든다. 다음 이 cell state를 얼마만큼 반영할 것인지를 나타내는 it를 곱하는 과정이다.

Ct라는 친구는 그 전에 있던 Ct-1에 forget gate layer를 곱하고 새롭게 만든 Ct~ 와 it를 곱한 값의 합으로 이루어져 있다. 

 

3) output은? 그니까 hidden state에 얼마만큼 반영할거야?

위와 같이 Ot는 이전의 hidden layer ht-1과 input Xt의 조합으로 sigmoid를 거쳐 나온 0~1사이의 값인데, 

그 값을 tanh(Ct)와 곱하여 나온 것이 최종적으로 ht로 업데이트 되는 구조이다.

 

LSTM의 변형! 도 존재하는데 아래는 peephole connections이다. 

각 forget과 input layer에도 바로 직전의 cell state인 Ct-1도 같이 넣어서 미세한 패턴이나 장기 의존성에 대해 더욱 감지능력이 향상되고, 특히 시계열 데이터 등에서 높은 성능을 보인다고 한다. 

 

또한 ft와 it가 반대라고 생각할 수 있다는 관점에서 보면, 

위와 같은 식을 사용하는 경우도 있다고 한다..

 

다음 LSTM변형 중 가장 많이 사용하는 Gated Recurrent Unit인 GRU이다.

이 친구는 forget gate와 input gate를 합쳐서 새로운 "update gate"를 만들었다. 

또한 cell state와 hidden state를 merge하여 사용하였는데, 전체적으로 LSTM에 비해 더 간단해졌다고 한다. 

 

@다시 우리의 강의로 돌아오면@

• Ct : 그 전에 있던 Ct-1에 대해서 얼만큼 forgeting할 것인가, 그리고 새로운 state에 대해서 얼만큼 input으로 사용할 것인가
• ht : 구한 Ct를 ht에 얼마나 적용시킬 것인가를 적용시켜 ht를 업데이트! 

자 그럼 gradient는 어떻게 흘러가는지 보자!

Ct에서 Ct-1로 가는 backpropagation과정을 보면 실제로 f를 곱하는 multiplication만 존재한다. 사실 더하는 과정은 앞에 6강에서 보았듯 gradient를 그대로 흘려주기에 고려하지 않아도 된다. 

 

따라서 이를 우리는 Uninterrupted gradient flow라고 이야기 한다. 

전혀 방해되지(?) 않고 끝가지 gradient flow가 흐른다! 라는 의미이다.. 아마도!

matrix multiplication과 nonlinearity도 존재하지 않기 때문에 uninterrupted라고 이야기 하는 것같다. 

CNN 아키텍처에서 보았던 ResNet의 backporp과정과 같이 gradient가 쭈욱 끝까지 이어진다. 

 

지금까지 우리는 single-layer RNN에 관련된 이야기를 했다.

hidden state layer가 하나만 있기 때문이었다. 

 

하지만 좀 더 deep하게 hidden state layer를 늘리면

Mutilayer RNN이라고 한다. 

위와 같이 state의 개수를 늘려 좀 더 deep하게 확장을 시킬 수 있다. 

 

위에서도 언급했듯 다양한 RNN의 변형들이 있는데, 

• GRU

 

또한 RNN Architectures에 대해서도 Neural Architecture Search 기법을 써보니 

LSTM보다 오른쪽에 있는 Learned Architectures가 더 성능이 좋더라! 라는 결과가 있었다고 한다.

 

오늘의 써머리! 

• RNN은 기존의 input과 output이 하나씩만 있는 형태가 아니라 좀 더 flexibility한 형태인데 
• Vanilla RNN은 simple하지만 잘 작동하지 않았고, 그래서 
• LSTM과 GRU를 자주 사용한다. 
• RNN에서 backward는 explode되거나 vanish하게 되었는데 
  • explode : gradient cplipping
  • vanish : 해결 x -> LSTM이라는 new model 사용! 
• LSTM : RNN + cell state 느낌 
• 현재 우리는 더 간단하고 더 심플한 아키텍처를 만드는 게 목적이다! 

---

 

드디어 다 쓴 요번주 포스팅! RNN! 

RNN.. LSTM 요런 친구들은 왠지 정이 많아서 

더 자세히 파고드려했는데 

그 부분이 날라가서 마음이 좀 많이 아팟어.. 

포스팅하고 다시 수정하면서 채워가려구 합니다.. 

어제 쓰러질 뻔 한(?) 이슈 후에 

열심히 공부하러 학교 온 사람이야 

이친구가 나의 스트레스의 8할을 책임지는 것 같긴한데 

뭐 어쩌겟니 ~ 해야지