PyTorch Lecture 12: RNN1 - Basics

이번 강의에서는
RNN에 대해 배워보도록 하겠습니다

이건 아주 흥미로운
학습 아키텍쳐 중 하나죠

이전 강의에서는
DNN에 대해 배웠습니다

네트워크의 레이어가 있고

주어진 입력값을
앞으로 넘겨주기만 하면

예상 출력값을 얻을 수 있죠

또는 예측값을 말이죠

그리고 CNN은
약간 달랐습니다

CNN은 주어진 입력값에 대해서

모든 입력값을 사용하는 대신

특정 부분에 대해서만 적용합니다

특성을 자동으로 추출하고

그 다음 레이어로 이동하죠

따라서 이미지에 대해
굉장히 효율적으로 작동합니다

RNN은
순환신경망을 의미하는데

굉장히 특이합니다

여기에서도 마찬가지로
x를 입력으로 넣으면

출력값을 생성합니다

하지만 그와 동시에
또 다른 출력값이 생기는데요

이것을 대개 은닉 단계
또는 은닉 상태라고 합니다

이 값은 다음 셀로 넘겨지게 됩니다

이것을 펼쳐서 보도록 하겠습니다

여기서 x₁, x₂와 같은
입력값을 가집니다

그리고 출력값을
차례로 생성하죠

여기서 아주 흥미로운 점은

이 첫 번째 셀에 대해서

출력값이 다음 셀의
입력값으로 전달된다는 점입니다

이 셀에서의 입력값은

이전의 데이터와
이 입력값이 되는 것이죠

이 값들로
이 출력값을 생성합니다

그리고 주어진 셀 중에서

이 셀을 예로 들자면

여기서 입력값을 x라고 하죠

또한 이전 단계의
은닉 상태도 입력 값으로 사용하죠

그리고 이것으로
출력값을 생성합니다

이 부분 때문에 우리는
이전의 상태를 기억하는 것과 같죠

이것들을 사용해서

다음의 출력값을 생성합니다

왜 이 방법이 좋은 것일까요?

우리가 가진 많은 양의 데이터를
데이터열 또는 시계열이라고 하죠

우리는 다양한 시계열을 가질 수 있는데

주가를 예측하는 것도 그중 하나입니다

이것을 RNN에
굉장히 유용하게 사용할 수 있죠

또는 RNN이 여기에
유용하다고 할 수도 있을 겁니다

언어 모델링도 그중 하나입니다

언어를 이해하는 부분은

제가 이전에 내용을
모두 이해하고 있어야 하겠죠

그렇게 해야 지금 제가 말하는
내용을 이해할 수 있게 됩니다

제가 지금 말하고 있는
내용 또는 발음만 이해하는 것은

언어를 제대로
이해한 것이 아니죠

따라서 언어 모델링에도
RNN이 유용하게 사용됩니다

또한 텍스트를
다룰 때에도 비슷합니다

텍스트 감성 분석이라고 하죠

개체명 인식도 포함됩니다

번역, 음성 인식 등도 포함되죠

RNN을 다양한 방법으로
합성할 수 있는데요

굉장히 다양한 모델이 있죠

예를 들어 여기서는
한 개의 입력으로 시작합니다

그리고 이 RNN은
여러 개의 출력값을 만들어내죠

예를 들어 한 개의 이미지를
입력으로 넣고

신경망이 이미지에
캡션을 달도록 한다고 해 봅시다

따라서 각각의 출력값은
단어가 되겠죠

이것으로 우리는 이 이미지가
무엇인지 알 수 있게 됩니다

또한 RNN을
다대일의 형태로 만들 수도 있습니다

그러면 문장에 포함되는
여러 개의 단어를 사용할 수 있겠죠

이렇게 문장의
감성 분석을 할 수 있습니다

출력은 한 개가 될 것이고

슬픔, 행복, 행복하지 않음 등의
결과가 나오겠죠

또한 RNN을 다대다의
형태로 구성할 수 있습니다

이 형태는 번역에 자주 사용됩니다

예를 들어
한국어로 된 문장들을 입력하면

영어로 된 새로운
문장으로 번역하는 것이죠

이런 형태를 가지는 RNN 모델이
자주 사용됩니다

RNN에 대해 이야기해야 할
주제가 여러 가지 있는데요

먼저 기본적인 내용을 공부하고

이 RNN으로 매우 간단한
언어 모델을 학습시킬 겁니다

'hello'를 말할 수 있게
학습시켜 보도록 하죠

RNN으로 분류도 해볼 겁니다

또 더 나은 언어 모델을
만들어 보고

마지막으로 시퀀스에서
시퀀스 만드는 것을 해보겠습니다

이 강의에서 하나씩
해보도록 하겠습니다

이 RNN을 사용해보기 전에

이것에 대해 약간
더 자세히 알아보도록 하죠

보통 RNN을 표현하기 위해
이러한 다이어그램을 사용합니다

이건 여기 굉장히 유명한
블로그에서 가져왔고요

내부를 보면
굉장히 간단합니다

한 개의 입력을 x라고 한다면

여기서 출력을 생성하게 되죠

이 출력값을 얻기 위해서
우리가 해야 하는 것은

이전 셀의 은닉 상태를
알아내는 것입니다

그리고 이것을 연결시키죠

이제 여기서 행렬곱을 계산합니다

h₁₀이 나올 때까지 말이죠

그리고 이 값을 분리해서
한 개는 출력값으로 하고

다른 값은 다음 셀에 넘겨줍니다

이것이 굉장히 간단하고
일반적인 형태의 RNN입니다

PyTorch를 이용해
RNN을 사용하기 위해서는

세부적인 내용을
모두 이해할 필요는 없습니다

단순하게 RNN을
이런 방식으로 사용하면 되죠

우리가 설정해야 하는 부분은

입력의 개수와
출력의 개수입니다

여기에서는 출력의 개수를
hidden_size라고 표현합니다

그리고 어떻게 데이터를
정렬할 것인지를 정해주는데요

이 부분은 batch_first라는
옵션을 통해 정할 수 있습니다

여기에선 이 batch_first를
포함시키도록 하겠습니다

RNN을 사용하는 것뿐만 아니라

GRU을 사용할 수도 있고

LSTM이라고 부르는 아주 유명한
RNN을 사용할 수도 있습니다

모두 동일한 상태에서
이름만 바꿔서 사용할 수 있습니다

따라서 다양한 형태의 RNN을
모두 사용할 수 있죠

예시로 RNN을 사용해 봅시다

여기서 input_size는 4로 설정하고

출력값의 개수인
hidden_size는 2로 설정하겠습니다

이것은 각 입력 벡터의
크기가 4가 되고

출력은 2개의 값을 가지게 되므로

벡터의 크기는 2가 되겠죠

여기서 입력을 정하는데요

이 RNN은
은닉 입력값도 필요로 합니다

초기값으로 말이죠

초기 hidden 값을
만들어주어야 합니다

여기에 넣어주면 됩니다

inputs는 여기에 넣고
hidden은 여기에 넣으면 되죠

이제 cell이 우리가 사용할
RNN이 되겠죠

이 hidden은 일단 한번
cell을 실행하고 나면

한 개의 출력값을 생성하고

이 경우엔 이 값이 되겠죠

여기가 출력값이 되고

이 부분은
은닉 상태로 사용하는 것이죠

이 hidden은 다음 셀에서 사용됩니다

여기서 이것을 한 번 더 호출할 때
이 hidden 값이 사용되는 것이죠

예를 들자면 또 다른 입력값들과

이 hidden이 여기에
다시 사용됩니다

이것이 RNN에
일반적으로 사용되는 개념이죠

이 hidden 값은 다음 셀로
넘어가서 사용된다는 것입니다

실제 예시로
실제로 글자를 넣어보겠습니다

h, e, l, l, o를 RNN에 넣어 봅시다

이 글자들을
입력값으로 설정하는 거죠

어떻게 해야 할까요?

각 글자를 다루는
간단한 방법 한가지는

원-핫 인코딩으로 바꾸는 방법입니다

먼저 모든 글자를 한번에 모은 후

각각에 식별자를 부여합니다

0, 1, 2가 되겠죠

고유한 식별자이기 때문에
이건 동일한 값을 가집니다

그리고 여기는 3이 되죠

이제 각각에
원-핫 인코딩을 해 봅시다

예를 들어 여기에서
h는 0이기 때문에

이것은 0 원-핫이 됩니다

따라서 [1, 0, 0, 0]이 되죠

e는 1이므로
[0, 1, 0, 0]이 됩니다

이렇게 각 글자를
원-핫 인코딩으로 정의할 수 있죠

이제 이것을 사용해 봅시다

여기서 단순하게 어떤 값을
넣어주는 것이 아니라

입력에 원-핫으로
만들어진 값을 넣어줍니다

이 경우에
입력 벡터의 차원은 4가 됩니다

각 벡터에 4개의 값이
포함됨을 의미하죠

이 값을 넣어주는 겁니다

이런 방식을 사용합니다

이제 이 셀의 출력값이
두 개임을 알고 있습니다

hidden_size를
2로 설정했기 때문이죠

따라서 출력값의 개수는
2개가 됩니다

따라서 이 셀에서는
2개의 값을 얻게 되죠

이 RNN 셀을 사용하는
기본적인 방법이라고 할 수 있죠

이제 코드를 한 번 봅시다

먼저 RNN을 사용해서
cell을 생성합니다

입력 개수와 출력 개수만
설정해주면 되죠

그리고 이제 입력값을 만듭니다

여기서 h를
원-핫 벡터로 정의했었죠

따라서 여기서 변수 h를 넣어줍니다

그리고 이것을
벡터로 만들어줍니다

지금 하려고 하는 것은
rank를 만들고자 하는 건데요

(1, 1, 4)로 만들겁니다

여기서 가장 중요한 부분은

입력의 개수가 4이므로

원-핫으로 만들어진
h는 네 개의 백터라는 것입니다

이렇게 inputs를 만들었고요

이제 hidden을 만들어보겠습니다

초기 hidden 값을 입력해야 하죠

이것은 이러한 방법으로 할 건데요

hidden_size를 가지고
레이어의 개수를 구할 수 있습니다

여기서는 디렉션의 개수가 되죠

batch의 크기와
hidden_size를 이용합니다

이건 출력의 개수와 같죠

이 경우에는 레이어 한 개와
디렉션 한 개만 사용할 겁니다

따라서 1이 되죠

이 예시에서 batch 또한 1이 됩니다

한 개의 배치만 사용하는 거죠

그리고 출력의 개수인
hidden_size는 2가 되죠

따라서 이렇게 만들 수 있습니다

초기값이므로 단순히
임의의 값을 만들고

그 값을 넣어줍니다

이제 이 cell을 호출하겠습니다

방금 만들었던 inputs와
초기 hidden값을 이용하죠

이렇게 넣어주면
출력값과 hidden값이 생깁니다

hidden의 경우
이 cell을 다시 호출하게 되면

이 hidden값을 사용하게 되죠

따라서 다음 셀과 연결시키는 것이죠

이것을 출력해보면
우리가 알고 있듯이

hidden_size가 2이므로
두 개의 값을 얻게 됩니다

여기서 두 개의 벡터 값이
나오는 이유가 그것이죠

이제부터 할 것은
굉장히 쉬운 내용인데요

어떻게 이 RNN 셀이
작동하는지 보도록 하죠

우리는 한 글자씩
일일이 넣는 것을 원하지 않죠

굉장히 느리고 비효율적입니다

따라서 여기서 할 것은

동시에 여러 글자를
넣어주는 것입니다

RNN에서는 이러한 것을
시퀀스라고 부릅니다

이전의 시퀀스 크기는 1이었지만

지금 우리가 하려고 하는 것에는
한 글자만 넣는 것이 아니라

h, e, l, l, o를 넣게 되는 거죠

총 5개의 글자입니다

따라서 시퀀스의 크기가
5라고 할 수 있죠

시퀀스 사이즈가 5인
이 경우에는 어떻게 해야 할까요?

다른 것들은 바꿀 필요 없이

입력의 형태만 바꿔주면 됩니다

이전에는 (1, 1, 4)의 형태였죠

배치가 1이고
시퀀스도 한 개였습니다

글자 한 개였죠

한 개의 글자는
벡터의 크기가 4였습니다

하지만 지금 보는 것에서는
이 부분이 바뀌어야 합니다

시퀀스가 들어가는 부분이죠

이런 형태의
데이터셋을 준비하고

이것들을 우리가 만든
셀에 넣어줍니다

바로 이렇게 됩니다

소스 코드를 한 번 보죠

이전과 비슷하게
이 RNN 셀을 만듭니다

input_size가 4이고
hidden_size는 2가 됩니다

여기서 차이점은
더 많은 데이터를 넣는 것인데요

한 글자만 넣는 것이 아니라

여러 개의 글자를 넣는 것이죠

크기가 5인 시퀀스가 됩니다

따라서 이것의 형태는
(1, 5, 4)가 될 겁니다

그리고 이제
이 hidden값을 생성하죠

이것은 이전과 동일합니다

이것을 셀에 넘겨주고

출력값들을 보면

여기가 시퀀스 크기가 되고

2는 출력값의 크기가
되는 것을 알 수 있습니다

따라서 이 값들을 그대로
셀에 넘겨주면 되죠

여기서 차이점은
다른 형태의 입력값을 만든 건데요

따라서 이 RNN이
이것을 잘 다룰 수 있게 되는 것이죠

마지막으로 한 번에
한 개의 글자만 다루거나

한 단어만 다루는 것은
부족할 겁니다

따라서 여러 개의
단어를 한 번에 넣고자 하는데요

예를 들어 여기에서는
hello, eolll, lleel을 넣는 거죠

여러 개를 한 번에 넣고자 하는 겁니다

이러한 경우를 배치라고 합니다

여기에서도
다른 것은 모두 동일합니다

입력의 형태만 바뀌게 되는데요

이전엔 이 값이 1이었지만
이제 3이 됩니다

3개의 배치를 가진다는 의미죠

소스 코드에서
어떻게 되는지 보겠습니다

이전과 굉장히 비슷한데요

이렇게 세 개의 배치가 있을 겁니다

그리고 이것들을 넣어줄 건데요

이 rank에 집중해봅시다

3은 배치의 개수를 뜻하죠

5는 시퀀스 크기를 의미합니다

이것은 원-핫의 크기를 뜻하죠

따라서 이 배치를
넣을 수 있게 됩니다

이 옵션을 사용한 이유가
여기에 있습니다

batch_first를 True로 설정했죠

따라서 이 값을 inputs로 사용하게 됩니다

hidden에서 다른 점은

이 batch 값에
3을 넣는 다는 건데요

따라서 3개의 배치를
사용하는 것으로 바꿔줍니다

그리고 이제 이전과 동일하게
cell을 호출합니다

그렇게 되면 예측값은

배치의 크기는 3
시퀀스 크기는 5가 되고

그리고 이 부분이
은닉 출력값이 되는 것이죠

이런 형태를 얻게 될 겁니다

이제부터 보실 내용은

각 셀에서 데이터를 RNN 셀에게
어떻게 넘겨주는지를 이해하는 부분인데요

여기서 하려는 것은
실제로 이 모델을 훈련시켜서

의미있는 작업을
할 수 있도록 하는 겁니다

이 예시는 매우 간단합니다

여기서 학습시키고자 하는 것은
'hihello'를 말하도록 하는 것인데요

이 RNN 셀들에
한 글자씩을 넣어줍니다

그러면 이 RNN은
다음 글자가 i라고 예측하는 것이죠

그리고 i를 넣어주면

그것에 대한 다음 글자를 예측합니다

이 경우엔 h가 되겠죠

주어진 글자에 대해

다음 글자가 무엇이 될지
예측하는 동작을 합니다

그러면 이 RNN을
어떻게 디자인해야 할까요?

기본적으로 입력값들은

이 경우에는
단어가 몇 개 더 있죠

h, i, e, l, o
다섯 개의 글자가 있고요

이것들을 5개의
원-핫으로 만들 수 있습니다

따라서 입력의 크기는
5가 될 것입니다

출력도 동일하겠죠

따라서 출력의 크기도 5가 됩니다

여기에서 예측하고자 하는 것은

5개의 글자 중
어떠한 한 개이기 때문이죠

따라서 이건 5가지 중에서의
다중 분류가 되겠네요

따라서 이건 5가지 중에서의
다중 분류가 되겠네요

따라서 출력값도
5개가 나올 것이라 생각할 수 있죠

우리가 만든 신경망은 이렇게 되겠죠

그러면 이제 손실 함수는
어떻게 디자인해야 할까요?

손실 함수를 디자인하면
역전파를 할 수 있죠

따라서 이 신경망을
훈련시킬 수 있습니다

간단하게 입력의 차원이 5라면

출력 또한 5개의 차원을 가지고 생성됩니다

이것은 레이블인데요

이 값이 y값이 되는 거죠

정답일 수도 있고요

y의 예측값이 됩니다

이제 이것으로
차이를 계산할 수 있습니다

그것을 손실이라고 부르는데요

이 경우는
다중 분류이기 때문에

다중 분류의 경우는

크로스 엔트로피를 사용합니다

이것뿐만 아니라

각 글자에 대해
손실 함수를 적용하고

이 손실을 모두 더해서

손실 값을 최소화하도록 하는 겁니다

소스 코드를 한번 보도록 하죠

가장 먼저 각 글자에 대해
고유한 인덱스를 만들어야 합니다

여기서는 h, i, e, l, o가 있죠

각각 0, 1, 2, 3, 4가 됩니다

여기서 이 x_data로
hihell를 표현하겠습니다

인덱스를 사용해서
0, 1, 0, 2, 3, 3으로 표현할 수 있습니다

그리고 이것을 원-핫으로 표현합니다

이렇게 원-핫을 만들고

y_data는 레이블 값입니다

이 값이 예측하고자 하는 값이죠

hiello가 올바른 값이죠

h가 주어지면
예측값은 i가 됩니다

i에 대해서는
h가 예측값이 되죠

따라서 이것을 각각의
id로 표현하면 이렇게 됩니다

1은 i가 되고
0은 h, ... 등등이 되겠죠

그리고 Variable을
이용해 입력값을 만들어줍니다

또한 레이블도 만들어줍니다

원-핫 룩업을 만드는
더 좋은 방법은

룩업 테이블처럼 만드는 것입니다

파이썬에서의 표현을 이용하는데요

이 x_data를 나눠서
각 x 값을 얻어냅니다

그리고 이 원-핫 룩업 테이블을 사용해

각 원-핫을 만들어낼 수 있습니다

원-핫 벡터를 얻는
약간 더 좋은 방법이죠

이제 나머지 부분은 동일합니다

몇 가지 매개변수를 설정해야 하는데요

클래스의 개수는 5가 되고

입력의 크기도 5가 됩니다

그리고 hidden_size
즉 출력의 크기도 5가 됩니다

배치는 한 개가 될 것이고
시퀀스의 길이도 1이 됩니다

레이어의 개수도 1개가 되죠

한 곳에 모든 매개변수를
선언하면 매우 좋은데요

필요할 때 값을
바꾸기만 하면 되기 때문이죠

우리의 모델은
PyTorch를 사용할 겁니다

클래스를 하나 만들고

먼저 초기화 함수 부분을 보도록 하죠

여기서 먼저 하는 것은
RNN을 생성하는 것입니다

주어진 input_size와
hidden_size로 생성하죠

새로운 RNN 셀을 한 개 생성합니다

forward 함수에서는

입력값으로 x값을 받고

두 번째 입력값으로
hidden을 받습니다

이 값들을 여기에 넣어줄 겁니다

이게 기본적인 개념인데요

이것을 하기 전에 x가 어떤 형태인지
확실히 보도록 합시다

batch size, sequence length
input size를 통해서 말이죠

x가 올바른 형태인지 확인한 후에

이 x를 여기로 넘겨줄 겁니다

따라서 hidden을 얻을 수 있습니다

그리고 출력값의 경우에는

일단 RNN에서
출력값을 얻게 되면

이제 손실값을
계산해야 합니다

따라서 출력 rank의 실제 크기가 어떻게 될지
생각해보아야 하죠

우리가 디자인해야 할
출력의 형태를 생각해야 하는 거죠

생각해 봅시다

우리가 여기서
하고자 하는 것은

다섯 개의 값들 중에서
한 개를 에측하는 것이죠

출력에서 몇 개의 글자가 있는지 모르고 있죠

또는 몇 개의 시퀀스가 있는지 말이죠

물론 이 값은 N이 되겠죠

하지만 지금 예측하려는
실제 값은 1과 5가 될 겁니다

따라서 y 예측값은
N × 5 행렬이 됩니다

따라서 이 출력값들에 대해
알아두셔야 할 부분은

reshape를 사용할 것이라는 점이죠

이렇게 5를 넣어서 말이죠

이 값에 n을 넣고

그리고 벡터의 크기에는
5를 넣는 것이죠

이러한 방법으로 출력값을 만듭니다

손실값을 더 효율적으로
계산하기 위해서죠

이렇게 해서 출력값이
이 형태를 가지도록 하는 겁니다

이 출력값을 이용해
손실을 계산할 수 있습니다

손실은
크로스-엔트로피를 사용할 건데요

이전 강의에서도 사용했었죠

여태까지 본 것이 기본이 되고

이제 하려는 것은
이 글자들을 한 개씩 넣어서

출력값을 얻고
손실을 계산하는 것이죠

이것을 하면서

이전 셀로부터
은닉 상태를 계속 넘겨줍니다

모든 은닉 상태는
이전 셀에서 얻을 수 있죠

이것을 해볼 텐데요

for문을 사용해서
간단하게 구현할 수 있습니다

먼저 손실은 0에서 시작합니다

그리고 이 모델에 대한
초기 은닉 상태 값을 얻습니다

for문에서
각 입력값을 얻어내는데요

각 한 글자씩을 얻고

각 레이블을 한 개씩 얻습니다

그리고 이 모델을 실행시키죠

inputs와 hidden을 넣어줍니다

그렇게 output과
hidden을 생성하죠

그리고 이 output은
레이블 값을 이용해서

손실을 계산하기
위해 사용됩니다

그리고 손실 값을
계속해서 누적되죠

그리고 다음 루프에서
이 hidden을 보면

이 hidden은
다음 셀의 입력으로 사용됩니다

다음 모델에 이용되죠

여기서 사용되는 거죠

다음 셀의 hidden 값으로
이용되는 것입니다

손실을 계산한 후에
backward()를 호출하여

이 모델을 다시 훈련시킵니다

한 번에 하나씩 이루어지죠

전체적인 코드입니다

각 반복, 즉 각 훈련마다

모델이 실제로 예측할 것이
무엇인지 알 수 있습니다

이 출력은 예측값을 포함하고 있죠

이 값을 출력해서

모델이 어떻게
동작하는지 볼 수 있겠죠

예상하시는 것처럼
처음 시작 부분에는

손실값은 상당히 높습니다

그리고 예측값은
거의 무작위 상태입니다

시간이 지날수록
다음 글자를 잘 예측하게 되죠

상당히 좋지만
한 가지 문제가 있습니다

여기에서 각 글자마다 반복문을
실행하고 싶지 않다는 것이죠

이전에 했던 것과 같이
한 번에 모두 넣을 수 있어야 합니다

이건 쉬운데요

기본적으로 이전과 같이
모델을 만들 수도 있습니다

하지만 한 글자씩을
넣고 루프를 실행하는 것보다

전체 입력을
한 번에 넣을 수도 있습니다

이전 예시에서
했던 것과 완전히 똑같죠

다른 것은 모두 동일하면서
입력값만 바뀝니다

그리고 레이블도 넣어줍니다

따라서 손실값을 얻을 수 있죠

여기서 모든 inputs와
초기 은닉 값으로 모델을 수행하고

출력값을 생성합니다

그리고 이 출력값과
레이블 값을 이용해서

손실값을 얻을 수 있습니다

정확히 동일한 형태죠

반복문을 사용하지 않고
전체 입력을 한번에 넣어줍니다

이렇게 손실 함수를
계산할 수 있습니다

좋습니다
설명은 여기까지고요

연습을 위해서
해보아야 할 것은

이제 다중 소프트맥스 분류기를
구현할 수 있기 때문에

주어진 글자에 대해
다음 글자를 예측하도록 만들 수 있죠

다음 글자를 예측할 때

소프트맥스 분류를 사용하면 됩니다

가능할까요?

이게 이번에 할 연습입니다

시도해보신다면

잘 동작하지 않는
이유를 설명할 수 있을 겁니다

그 이유 중 하나는

각 소프트맥스가
이전 데이터를 받지 않기 때문이죠

이전 데이터는
전혀 알 수가 없어요

주어진 상태만 가지고

다음 상태를
예측하는 것은 어려운 일이죠

다음 연습 문제는
이 RNN과

소프트맥스 분류기를
결합하는 것입니다

이건 굉장히
일반적인 모델인데요

이 RNN을 사용하면서

이 RNN 위에
또 다른 완전 연결 층을 추가합니다

이 문제는 굉장히 어렵습니다

이것을 직접 해보시면

좀 더 빠르게
훈련시킬 수 있습니다

왜 이것이 더 빠르고
안정적인지 생각해보아야겠죠

우리가 사용한 예시에서는
원-핫 인코딩을 사용했죠

굉장히 간단했습니다

또 다른 방법이 있는데요

가끔 이게 더 좋은 방법이기도 하죠

임베딩이라는
개념을 사용하는 건데요

원-핫 방식과 동일한데요

원-핫의 경우
고정된 값을 사용합니다

하지만 임베딩의 경우

예를 들어 여기에
몇 가지 인덱스가 있을 때

각각에 값을 부여합니다

이 값은 훈련시킬 수 있는 값인데요

이 훈련 가능한 값은
향상된 모델을 만들도록 도와줍니다

이것을 사용하는 방법은
굉장히 간단합니다

이렇게 단순히
임베딩을 생성하면 되죠

단어의 크기와
출력의 크기를 넣어주면 됩니다

이렇게 정의한 후에

이 x 입력값을 넣어주면

임베딩을 생성해주죠

예시로 이러한
임베딩을 만들 수 있는 거죠

단어 크기와 임베딩 크기는 이렇습니다

굉장히 간단하죠

다른 연습 문제에서
임베딩을 사용해볼 수 있습니다

임베딩을 사용해서

RNN와 완전 연결층을
그대로 구현할 수 있습니다

원-핫 인코딩 대신에
여기에 임베딩을 넣는 것이죠

마지막으로 보게될 부분은

RNN이 내부적으로
어떻게 동작하는지에 대한 것입니다

RNN은 이런 방식으로
표현할 수 있죠

x를 입력값으로 하고

이전의 은닉 상태도
또 다른 입력값으로 가집니다

그리고 새로운 은닉 상태와

출력값을 만들어 냅니다

이것을 식으로
표현해볼 수 있는데요

이 일반 (vanila) RNN 또는
간단한 형태의 RNN은

매우 간단합니다

주어진 x에 대해서

웨이트 U를 가지고

이전 은닉 상태에 대해서
웨이트 W를 가집니다

이 두 값과
편향 값을 더해 줍니다

그리고 여기서
이 값은 훈련 가능한 값입니다

여기 이 값을 a라고 하고

은닉 상태는 간단하게
tanh(a)로 계산합니다

출력값의 계산에는
또 다른 변수를 사용하는데요

이 값도 물론 훈련 가능한데

이 Vh에
또 다른 편향값 c를 더해줍니다

이 값이 출력값이 되죠

여기까지가 기본적인
RNN이 됩니다

그리고 이 y 예측값은

이 출력값에 소프트맥스를
통과시킨 값이 됩니다

이렇게 RNN이 동작합니다

LSTM은 약간 복잡한데요

기본적으로 여러 개가
연결되어있는 것이라고 할 수 있죠

이 블로그를 참고하시면 됩니다

또 다른 RNN인
GRU에 대해서도

이 식을 보면 어떻게
연결되어있는지 이해할 수 있습니다

연습 문제에서 작동하는 원리를
확실히 이해하고 싶다면

이것을 직접 구현해보면 됩니다

새로운 클래스를 만들고

은닉 상태를 정의하죠

이 부분이 은닉 상태죠

이 식을 사용해서 은닉 상태와
출력을 정의할 수 있습니다

이것을 한번 구현해보시면
훨씬 더 잘 이해할 수 있을 겁니다

GRU도 똑같이 구현해볼 수 있습니다

이렇게 첫 번째
RNN 강의를 마치겠습니다

다음 강의에서
더 배워보도록 하죠