์๋ ํ์ธ์. ์ค๋์ RNN์ Pytorch๋ก ์ง์ ๊ตฌํํด๋ณด๊ณ , Tanh(hyperbolic tangent) ๋์ , Sigmoid๋ ReLU๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ป๊ฒ ๋๋์ง ์คํ์ ํ ๋ฒ ํด๋ณด๊ฒ ์ต๋๋ค.
www.youtube.com/watch?v=tlyzfIYvMWE&list=PLSAJwo7mw8jn8iaXwT4MqLbZnS-LJwnBd&index=26
์ ๊ฐ Pytorch๋ฅผ ์ฒ์ ๊ณต๋ถํ ๋ ์ ์์์ ๋ง์ด ์ฐธ๊ณ ํ์ต๋๋ค.
Pytorch๋ฅผ ์ฒ์ ๊ณต๋ถํ์๋ ๋ถ์ด์๋ผ๋ฉด, ์ ๋ฅ๋ฌ๋ ํ๋ก์๊ธฐ Pytorch Kist ์์์ ๋ณด์๋ ๊ฑธ ์ถ์ฒ๋๋ฆฝ๋๋ค.
์๋ฃ๋ ์๋์์ด GIt์ ์ฌ๋ผ์ ์๊ณ , ๋ผ์ด๋ธ ์ฝ๋ฉ์ ํ๋ฉด์ ์์ ์ด ์งํ๋๊ธฐ ๋๋ฌธ์ ์ ๊ทผํ๋ ๋ ธํ์ฐ๋ฅผ ๊ธฐ๋ฅผ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ฝ๋๋ ์ ์์ GIthub์ ์๋ฃ๋ฅผ ์์ ํ ๋ด์ฉ์ ๋๋ค.
์ฐ์ RNN(Recurrent Neural Network)์ ๊ตฌ์กฐ ๋ํด ์ด์ผ๊ธฐ ํด๋ณด๊ฒ ์ต๋๋ค.
RNN์ Input๊ณผ Output์ Sequence ๋จ์๋ก ์ฒ๋ฆฌํ๋ ๋คํธ์ํฌ ๊ตฌ์กฐ์ ๋๋ค.
์ผ๋ฐ ์ ๊ฒฝ๋ง๊ณผ ๋ฌ๋ฆฌ ์ํ ์ ๊ฒฝ๋ง์ Cell ๋ถ๋ถ์ด ์ํํ๊ฒ ๋ฉ๋๋ค.
Hidden Layer๋ ๋ฐ๋ก ์ด์ Hidden Layer์ ์ ๋ ฅ์ ํ์ฌ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ๊ฐ์ฅ ํฐ ํน์ง์ ๋๋ค.
์ด๋ฐ RNN์ ์ํ ๊ตฌ์กฐ ๋๋ฌธ์ ์๊ณ์ด ๋ฐ์ดํฐ์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๊ณ ์์ต๋๋ค.
์ ๊ตฌ์กฐ๋ ๊ฐ๋จํ ์์ผ๋ก ํํํ ์ ์์ต๋๋ค.
๊ทธ๋ ๋ค๋ฉด activation function์ธ tanh ๋ง๊ณ , ์ง๊ธ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ค๋ ReLU๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ ๊น ๋ผ๋ ๊ถ๊ธ์ฆ์ด ์๊ฒผ์ต๋๋ค.
Sigmoid์ ๋ฏธ๋ถ์ ์ต๋๊ฐ์ด 0.25์ด๊ธฐ ๋๋ฌธ์, Deepํด์ง์๋ก Vanishing Gradient ๊ฐ ๋ฐ์ํฉ๋๋ค.
Vanishing ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ง๋ ๊ฒ์ด Tanh ์ ๋๋ค.
Tanh๋ 0~1์ธ Sigmoid ํ์ฅํ์ด๋ฉฐ, ๋ฏธ๋ถ์ ์ต๋๊ฐ์ด 1๋ก Vanishing Graidient๋ฅผ ํด๊ฒฐํฉ๋๋ค.
ReLU๋ -1~1์ ๋ฐํํ๋ Tanh ๋์ , x๊ฐ 0๋ณด๋ค ํฌ๋ฉด ๊ทธ๋๋ก ๊ฐ์ ๋ณด๋ด๊ฒ ๋์ด, ์๋์ ํ์ต๋ฅ ์ด ํฅ์๋์ต๋๋ค.
ํ์ง๋ง, RNN์ ๋ด๋ถ๋ ๊ณ์ ์ํํ๋ ๊ตฌ์กฐ๋ก ๊ฐ์ด 1๋ณด๋ค ํฌ๊ฒ ๋๋ฉด, ReLU ํน์ฑ์ ๊ฐ์ด ๋ฐ์ฐํ ์ ์๊ธฐ ๋๋ฌธ์ ์ ํฉํ์ง ์๋ค๊ณ ํฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด, ๊ฐ๋จํ ๋ฐ์ดํฐ์์ ๋ฐ์ฐํ์ง ์๋ ํ๊ฒฝ์์ ReLU๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ค๋ฉด ์ด๋ป๊ฒ ๋ ์ง ๊ถ๊ธํ์ต๋๋ค.
์ ์์์ Git ์ฝ๋๋ฅผ ์ฌ์ฉํ์ผ๋ฉฐ, ํ์ต์ด ์คํจํ ์์์ ๋๋ค.
์์ ์ ํ์ง ์๊ณ , ์ฝ๋๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ์ผ๋ฉฐ, ํ์ฑํ ํจ์๋ง ๋ฐ๊ฟ๊ฐ๋ฉด์ ํ์ต ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ์ต๋๋ค.
import torch
import torch.nn as nn
class RNN(nn.Module):
def __init__(self, input_dim, output_dim, hid_dim, batch_size):
super(RNN, self).__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.hid_dim = hid_dim
self.batch_size = batch_size
self.wx = nn.Linear(self.input_dim, self.hid_dim, bias=False)
self.wh = nn.Linear(self.hid_dim, self.hid_dim, bias=False)
self.wy = nn.Linear(self.hid_dim, self.output_dim, bias=False)
self.act_fn = nn.Tanh() # nn.Sigmoid() nn.ReLU() nn.LeakyReLU()
self.hidden = self.init_hidden()
def init_hidden(self, batch_size=None):
if batch_size is None:
batch_size = self.batch_size
return torch.zeros(batch_size, self.hid_dim)
def forward(self, x):
h = self.act_fn(self.wx(x) + self.wh(self.hidden))
y = self.wy(h)
return y, h
๋๋ต ์ด๋ฐ ๊ทธ๋ฐ ๊ทธ๋ฆผ์ด ๊ทธ๋ ค์ง๋๋ค. ๋ถ๋ช Loss ์ ๋ถ ๋จ์ด์ก์ผ๋ ๋ชจ๋ธ ์ฑ๋ฅ์ ๋ณ๋ก ์ธ ๊ฒ ๊ฐ์ต๋๋ค.
ReLU๊ฐ ์กฐ๊ธ์ด๋๋ง ๋ฐ๋ผ๊ฐ๋ ๋ฏํ๋ ๊ฐ์ ์์ธก์ ํ์ง ๋ชปํ์ต๋๋ค.
๊ทธ๋์ LeakyReLU๋ฅผ ์ฌ์ฉํด ๋ ๊ฒฐ๊ณผ๋ฅผ ํ์ธ ํ์ต๋๋ค.
LeakyReLU๋ฅผ ์ฌ์ฉํ์ ๋, Sinc ํจ์๊ฐ ๊ทธ๋ ค์ก์ต๋๋ค.
๊ถ๊ธ์ฆ์ ํด๊ฒฐํ๊ณ ์ ํ์ฑํํจ์๋ฅผ ๋ฐ๊ฟ๊ฐ๋ฉด์ ํ์ต์ ์์ผฐ์ผ๋ ์คํ๋ ค ๊ถ๊ธ์ฆ์ด ๋ ์ปค์ก์ต๋๋ค.
์ด ๋ถ๋ถ์ ์ข ๋ ๊ณต๋ถ๋ฅผ ํด๋ด์ผ ํ ๊ฒ ๊ฐ์ต๋๋ค... ๋ฅ๋ฌ๋ ๊ณ ์๋ถ๋ค ํผ๋๋ฐฑ ๋ถํ๋๋ฆฝ๋๋ค.